#! jQuery v1.11.0 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license 
not (a, b) ->
  (if "object" is typeof module and "object" is typeof module.exports then module.exports = (if a.document then b(a, not 0) else (a) ->
    throw new Error("jQuery requires a window with a document")  unless a.document
    b a
  ) else b(a))
  return
((if "undefined" isnt typeof window then window else this), (a, b) ->
  s = (a) ->
    b = a.length
    c = n.type(a)  
    (if "function" is c or n.isWindow(a) then not 1 else (if 1 is a.nodeType and b then not 0 else "array" is c or 0 is b or "number" is typeof b and b > 0 and b - 1 of a))
  x = (a, b, c) ->
    if n.isFunction(b)
      return n.grep(a, (a, d) ->
        !!b.call(a, d, a) isnt c
      )
    if b.nodeType
      return n.grep(a, (a) ->
        a is b isnt c
      )
    if "string" is typeof b
      return n.filter(b, a, c)  if w.test(b)
      b = n.filter(b, a)
    n.grep a, (a) ->
      n.inArray(a, b) >= 0 isnt c

  E = (a, b) ->
    loop
      a = a[b]
      break unless a and 1 isnt a.nodeType
    a
  H = (a) ->
    b = G[a] = {}
    n.each(a.match(F) or [], (a, c) ->
      b[c] = not 0
      return
    )
    b
  J = ->
    (if z.addEventListener then (z.removeEventListener("DOMContentLoaded", K, not 1)
    a.removeEventListener("load", K, not 1)
    ) else (z.detachEvent("onreadystatechange", K)
    a.detachEvent("onload", K)
    ))
    return
  K = ->
    (z.addEventListener or "load" is event.type or "complete" is z.readyState) and (J()
    n.ready()
    )
    return
  P = (a, b, c) ->
    if undefined is c and 1 is a.nodeType
      d = "data-" + b.replace(O, "-$1").toLowerCase()
      if c = a.getAttribute(d)
      "string" is typeof c
        try
          c = (if "true" is c then not 0 else (if "false" is c then not 1 else (if "null" is c then null else (if +c + "" is c then +c else (if N.test(c) then n.parseJSON(c) else c)))))
        n.data a, b, c
      else
        c = undefined
    c
  Q = (a) ->
    b = undefined
    for b of a
      continue
    not 0
  R = (a, b, d, e) ->
    if n.acceptData(a)
      f = undefined
      g = undefined
      h = n.expando
      i = a.nodeType
      j = (if i then n.cache else a)
      k = (if i then a[h] else a[h] and h)
      if k and j[k] and (e or j[k].data) or undefined isnt d or "string" isnt typeof b
        k or (k = (if i then a[h] = c.pop() or n.guid++ else h))
        j[k] or (j[k] = (if i then {} else toJSON: n.noop))
        ("object" is typeof b or "function" is typeof b) and ((if e then j[k] = n.extend(j[k], b) else j[k].data = n.extend(j[k].data, b)))
        g = j[k]
        e or (g.data or (g.data = {})
        g = g.data
        )
        undefined isnt d and (g[n.camelCase(b)] = d)
        (if "string" is typeof b then (f = g[b]
        null is f and (f = g[n.camelCase(b)])
        ) else f = g)
        f
  S = (a, b, c) ->
    if n.acceptData(a)
      d = undefined
      e = undefined
      f = a.nodeType
      g = (if f then n.cache else a)
      h = (if f then a[n.expando] else n.expando)
      if g[h]
        if b and (d = (if c then g[h] else g[h].data))
          (if n.isArray(b) then b = b.concat(n.map(b, n.camelCase)) else (if b of d then b = [b] else (b = n.camelCase(b)
          b = (if b of d then [b] else b.split(" "))
          )))
          e = b.length

          delete d[b[e]]  while e--
          return  if (if c then not Q(d) else not n.isEmptyObject(d))
        (c or (delete g[h].data

        Q(g[h])
        )) and ((if f then n.cleanData([a], not 0) else (if l.deleteExpando or g isnt g.window then delete g[h]
         else g[h] = null)))
    return
  bb = ->
    not 0
  cb = ->
    not 1
  db = ->
    try
      return z.activeElement
    return
  eb = (a) ->
    b = fb.split("|")
    c = a.createDocumentFragment()
    c.createElement b.pop()  while b.length  if c.createElement
    c
  vb = (a, b) ->
    c = undefined
    d = undefined
    e = 0
    f = (if typeof a.getElementsByTagName isnt L then a.getElementsByTagName(b or "*") else (if typeof a.querySelectorAll isnt L then a.querySelectorAll(b or "*") else undefined))
    unless f
      f = []
      c = a.childNodes or a

      while null isnt (d = c[e])
        (if not b or n.nodeName(d, b) then f.push(d) else n.merge(f, vb(d, b)))
        e++
    (if undefined is b or b and n.nodeName(a, b) then n.merge([a], f) else f)
  wb = (a) ->
    X.test(a.type) and (a.defaultChecked = a.checked)
    return
  xb = (a, b) ->
    (if n.nodeName(a, "table") and n.nodeName((if 11 isnt b.nodeType then b else b.firstChild), "tr") then a.getElementsByTagName("tbody")[0] or a.appendChild(a.ownerDocument.createElement("tbody")) else a)
  yb = (a) ->
    a.type = (null isnt n.find.attr(a, "type")) + "/" + a.type
    a
  zb = (a) ->
    b = qb.exec(a.type)
    (if b then a.type = b[1] else a.removeAttribute("type"))
    a
  Ab = (a, b) ->
    c = undefined
    d = 0

    while null isnt (c = a[d])
      n._data c, "globalEval", not b or n._data(b[d], "globalEval")
      d++
    return
  Bb = (a, b) ->
    if 1 is b.nodeType and n.hasData(a)
      c = undefined
      d = undefined
      e = undefined
      f = n._data(a)
      g = n._data(b, f)
      h = f.events
      if h
        delete g.handle

        g.events = {}

        for c of h
          continue
      g.data and (g.data = n.extend({}, g.data))
    return
  Cb = (a, b) ->
    c = undefined
    d = undefined
    e = undefined
    if 1 is b.nodeType
      if c = b.nodeName.toLowerCase()
      not l.noCloneEvent and b[n.expando]
        e = n._data(b)
        for d of e.events
          continue
        b.removeAttribute n.expando
      (if "script" is c and b.text isnt a.text then (yb(b).text = a.text
      zb(b)
      ) else (if "object" is c then (b.parentNode and (b.outerHTML = a.outerHTML)
      l.html5Clone and a.innerHTML and not n.trim(b.innerHTML) and (b.innerHTML = a.innerHTML)
      ) else (if "input" is c and X.test(a.type) then (b.defaultChecked = b.checked = a.checked
      b.value isnt a.value and (b.value = a.value)
      ) else (if "option" is c then b.defaultSelected = b.selected = a.defaultSelected else ("input" is c or "textarea" is c) and (b.defaultValue = a.defaultValue)))))
    return
  Fb = (b, c) ->
    d = n(c.createElement(b)).appendTo(c.body)
    e = (if a.getDefaultComputedStyle then a.getDefaultComputedStyle(d[0]).display else n.css(d[0], "display"))
    d.detach()
    e
  Gb = (a) ->
    b = z
    c = Eb[a]
    c or (c = Fb(a, b)
    "none" isnt c and c or (Db = (Db or n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement)
    b = (Db[0].contentWindow or Db[0].contentDocument).document
    b.write()
    b.close()
    c = Fb(a, b)
    Db.detach()
    )
    Eb[a] = c
    )
    c
  Mb = (a, b) ->
    get: ->
      c = a()
      (if c then undefined else (@get = b).apply(this, arguments_))  unless null is c
  Vb = (a, b) ->
    return b  if b of a
    c = b.charAt(0).toUpperCase() + b.slice(1)
    d = b
    e = Ub.length
    while e--
      return b  if b = Ub[e] + c
      b of a
    d
  Wb = (a, b) ->
    c = undefined
    d = undefined
    e = undefined
    f = []
    g = 0
    h = a.length

    while h > g
      d = a[g]
      d.style and (f[g] = n._data(d, "olddisplay")
      c = d.style.display
      (if b then (f[g] or "none" isnt c or (d.style.display = "")
      "" is d.style.display and V(d) and (f[g] = n._data(d, "olddisplay", Gb(d.nodeName)))
      ) else f[g] or (e = V(d)
      (c and "none" isnt c or not e) and n._data(d, "olddisplay", (if e then c else n.css(d, "display")))
      ))
      )
      g++
    g = 0
    while h > g
      d = a[g]
      d.style and (b and "none" isnt d.style.display and "" isnt d.style.display or (d.style.display = (if b then f[g] or "" else "none")))
      g++
    a
  Xb = (a, b, c) ->
    d = Qb.exec(b)
    (if d then Math.max(0, d[1] - (c or 0)) + (d[2] or "px") else b)
  Yb = (a, b, c, d, e) ->
    f = (if c is ((if d then "border" else "content")) then 4 else (if "width" is b then 1 else 0))
    g = 0

    while 4 > f
      "margin" is c and (g += n.css(a, c + U[f], not 0, e))
      (if d then ("content" is c and (g -= n.css(a, "padding" + U[f], not 0, e))
      "margin" isnt c and (g -= n.css(a, "border" + U[f] + "Width", not 0, e))
      ) else (g += n.css(a, "padding" + U[f], not 0, e)
      "padding" isnt c and (g += n.css(a, "border" + U[f] + "Width", not 0, e))
      ))
      f += 2
    g
  Zb = (a, b, c) ->
    d = not 0
    e = (if "width" is b then a.offsetWidth else a.offsetHeight)
    f = Jb(a)
    g = l.boxSizing() and "border-box" is n.css(a, "boxSizing", not 1, f)
    if 0 >= e or null is e
      return e  if e = Kb(a, b, f)
      (0 > e or null is e) and (e = a.style[b])
      Ib.test(e)

      d = g and (l.boxSizingReliable() or e is a.style[b])
      e = parseFloat(e) or 0
    e + Yb(a, b, c or ((if g then "border" else "content")), d, f) + "px"
  $b = (a, b, c, d, e) ->
    new $b::init(a, b, c, d, e)
  gc = ->
    setTimeout(->
      _b = undefined
      return
    )
    _b = n.now()
  hc = (a, b) ->
    c = undefined
    d = height: a
    e = 0
    b = (if b then 1 else 0)
    while 4 > e
      c = U[e]
      d["margin" + c] = d["padding" + c] = a
      e += 2 - b
    b and (d.opacity = d.width = a)
    d
  ic = (a, b, c) ->
    d = undefined
    e = (fc[b] or []).concat(fc["*"])
    f = 0
    g = e.length

    while g > f
      return d  if d = e[f].call(c, b, a)
      f++
    return
  jc = (a, b, c) ->
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = undefined
    i = undefined
    j = undefined
    k = undefined
    m = this
    o = {}
    p = a.style
    q = a.nodeType and V(a)
    r = n._data(a, "fxshow")
    c.queue or (h = n._queueHooks(a, "fx")
    null is h.unqueued and (h.unqueued = 0
    i = h.empty.fire
    h.empty.fire = ->
      h.unqueued or i()
      return

    )
    h.unqueued++
    m.always(->
      m.always ->
        h.unqueued--
        n.queue(a, "fx").length or h.empty.fire()

        return

      return
    )
    )
    1 is a.nodeType and ("height" of b or "width" of b) and (c.overflow = [
      p.overflow
      p.overflowX
      p.overflowY
    ]
    j = n.css(a, "display")
    k = Gb(a.nodeName)
    "none" is j and (j = k)
    "inline" is j and "none" is n.css(a, "float") and ((if l.inlineBlockNeedsLayout and "inline" isnt k then p.zoom = 1 else p.display = "inline-block"))
    )
    c.overflow and (p.overflow = "hidden"
    l.shrinkWrapBlocks() or m.always(->
      p.overflow = c.overflow[0]
      p.overflowX = c.overflow[1]
      p.overflowY = c.overflow[2]

      return
    )
    )

    for d of b
      continue
    unless n.isEmptyObject(o)
      (if r then "hidden" of r and (q = r.hidden) else r = n._data(a, "fxshow", {}))
      f and (r.hidden = not q)
      (if q then n(a).show() else m.done(->
        n(a).hide()
        return
      ))
      m.done(->
        b = undefined
        n._removeData a, "fxshow"
        for b of o
          continue
        return
      )

      for d of o
        continue
    return
  kc = (a, b) ->
    c = undefined
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    for c of a
      continue
    return
  lc = (a, b, c) ->
    d = undefined
    e = undefined
    f = 0
    g = ec.length
    h = n.Deferred().always(->
      delete i.elem

      return
    )
    i = ->
      return not 1  if e
      b = _b or gc()
      c = Math.max(0, j.startTime + j.duration - b)
      d = c / j.duration or 0
      f = 1 - d
      g = 0
      i = j.tweens.length

      while i > g
        j.tweens[g].run f
        g++
      h.notifyWith(a, [
        j
        f
        c
      ])
      (if 1 > f and i then c else (h.resolveWith(a, [j])
      not 1
      ))

    j = h.promise(
      elem: a
      props: n.extend({}, b)
      opts: n.extend(not 0,
        specialEasing: {}
      , c)
      originalProperties: b
      originalOptions: c
      startTime: _b or gc()
      duration: c.duration
      tweens: []
      createTween: (b, c) ->
        d = n.Tween(a, j.opts, b, c, j.opts.specialEasing[b] or j.opts.easing)
        j.tweens.push(d)
        d

      stop: (b) ->
        c = 0
        d = (if b then j.tweens.length else 0)
        return this  if e
        e = not 0
        while d > c
          j.tweens[c].run 1
          c++
        (if b then h.resolveWith(a, [
          j
          b
        ]) else h.rejectWith(a, [
          j
          b
        ]))
        this
    )
    k = j.props
    kc(k, j.opts.specialEasing)
    while g > f
      return d  if d = ec[f].call(j, a, k, j.opts)
      f++
    n.map(k, ic, j)
    n.isFunction(j.opts.start) and j.opts.start.call(a, j)
    n.fx.timer(n.extend(i,
      elem: a
      anim: j
      queue: j.opts.queue
    ))
    j.progress(j.opts.progress).done(j.opts.done, j.opts.complete).fail(j.opts.fail).always(j.opts.always)
  Mc = (a) ->
    (b, c) ->
      "string" isnt typeof b and (c = b
      b = "*"
      )
      d = undefined
      e = 0
      f = b.toLowerCase().match(F) or []
      if n.isFunction(c)
        while d = f[e++]
          (if "+" is d.charAt(0) then (d = d.slice(1) or "*"
          (a[d] = a[d] or []).unshift(c)
          ) else (a[d] = a[d] or []).push(c))
      return
  Nc = (a, b, c, d) ->
    g = (h) ->
      i = undefined
      e[h] = not 0
      n.each(a[h] or [], (a, h) ->
        j = h(b, c, d)
        (if "string" isnt typeof j or f or e[j] then (if f then not (i = j) else undefined) else (b.dataTypes.unshift(j)
        g(j)
        not 1
        ))
      )
      i
    e = {}
    f = a is Jc
    g(b.dataTypes[0]) or not e["*"] and g("*")
  Oc = (a, b) ->
    c = undefined
    d = undefined
    e = n.ajaxSettings.flatOptions or {}
    for d of b
      continue
    c and n.extend(not 0, a, c)
    a
  Pc = (a, b, c) ->
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = a.contents
    i = a.dataTypes
    while "*" is i[0]
      i.shift()
      undefined is e and (e = a.mimeType or b.getResponseHeader("Content-Type"))
    if e
      for g of h
        continue
    if i[0] of c
      f = i[0]
    else
      for g of c
        if not i[0] or a.converters[g + " " + i[0]]
          f = g
          break
        d or (d = g)
      f = f or d
    (if f then (f isnt i[0] and i.unshift(f)
    c[f]
    ) else undefined)
  Qc = (a, b, c, d) ->
    e = undefined
    f = undefined
    g = undefined
    h = undefined
    i = undefined
    j = {}
    k = a.dataTypes.slice()
    if k[1]
      for g of a.converters
        continue
    f = k.shift()
    while f
      if a.responseFields[f] and (c[a.responseFields[f]] = b)
      not i and d and a.dataFilter and (b = a.dataFilter(b, a.dataType))
      i = f
      f = k.shift()
        if "*" is f
          f = i
        else if "*" isnt i and i isnt f
          if g = j[i + " " + f] or j["* " + f]
          not g
            for e of j
              continue
          if g isnt not 0
            if g and a["throws"]
              b = g(b)
            else
              try
                b = g(b)
              catch l
                return (
                  state: "parsererror"
                  error: (if g then l else "No conversion from " + i + " to " + f)
                )
    state: "success"
    data: b
  Wc = (a, b, c, d) ->
    e = undefined
    if n.isArray(b)
      n.each b, (b, e) ->
        (if c or Sc.test(a) then d(a, e) else Wc(a + "[" + ((if "object" is typeof e then b else "")) + "]", e, c, d))
        return

    else if c or "object" isnt n.type(b)
      d a, b
    else
      for e of b
        continue
    return
  $c = ->
    try
      return new a.XMLHttpRequest
    return
  _c = ->
    try
      return new a.ActiveXObject("Microsoft.XMLHTTP")
    return
  ed = (a) ->
    (if n.isWindow(a) then a else (if 9 is a.nodeType then a.defaultView or a.parentWindow else not 1))
  c = []
  d = c.slice
  e = c.concat
  f = c.push
  g = c.indexOf
  h = {}
  i = h.toString
  j = h.hasOwnProperty
  k = "".trim
  l = {}
  m = "1.11.0"
  n = (a, b) ->
    new n.fn.init(a, b)

  o = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g
  p = /^-ms-/
  q = /-([\da-z])/g
  r = (a, b) ->
    b.toUpperCase()

  n.fn = n:: =
    jquery: m
    constructor: n
    selector: ""
    length: 0
    toArray: ->
      d.call this

    get: (a) ->
      (if null isnt a then (if 0 > a then this[a + @length] else this[a]) else d.call(this))

    pushStack: (a) ->
      b = n.merge(@constructor(), a)
      b.prevObject = this
      b.context = @context
      b

    each: (a, b) ->
      n.each this, a, b

    map: (a) ->
      @pushStack n.map(this, (b, c) ->
        a.call b, c, b
      )

    slice: ->
      @pushStack d.apply(this, arguments_)

    first: ->
      @eq 0

    last: ->
      @eq -1

    eq: (a) ->
      b = @length
      c = +a + ((if 0 > a then b else 0))
      @pushStack (if c >= 0 and b > c then [this[c]] else [])

    end: ->
      @prevObject or @constructor(null)

    push: f
    sort: c.sort
    splice: c.splice

  n.extend = n.fn.extend = ->
    a = undefined
    b = undefined
    c = undefined
    d = undefined
    e = undefined
    f = undefined
    g = arguments_[0] or {}
    h = 1
    i = arguments_.length
    j = not 1
    "boolean" is typeof g and (j = g
    g = arguments_[h] or {}
    h++
    )
    "object" is typeof g or n.isFunction(g) or (g = {})
    h is i and (g = this
    h--
    )

    while i > h
      unless null is (e = arguments_[h])
        for d of e
          continue
      h++
    g

  n.extend(
    expando: "jQuery" + (m + Math.random()).replace(/\D/g, "")
    isReady: not 0
    error: (a) ->
      throw new Error(a)return

    noop: ->

    isFunction: (a) ->
      "function" is n.type(a)

    isArray: Array.isArray or (a) ->
      "array" is n.type(a)

    isWindow: (a) ->
      null isnt a and a is a.window

    isNumeric: (a) ->
      a - parseFloat(a) >= 0

    isEmptyObject: (a) ->
      b = undefined
      for b of a
        continue
      not 0

    isPlainObject: (a) ->
      b = undefined
      return not 1  if not a or "object" isnt n.type(a) or a.nodeType or n.isWindow(a)
      try
        return not 1  if a.constructor and not j.call(a, "constructor") and not j.call(a.constructor::, "isPrototypeOf")
      catch c
        return not 1
      if l.ownLast
        for b of a
          continue
      for b of a
        continue
      undefined is b or j.call(a, b)

    type: (a) ->
      (if null is a then a + "" else (if "object" is typeof a or "function" is typeof a then h[i.call(a)] or "object" else typeof a))

    globalEval: (b) ->
      b and n.trim(b) and (a.execScript or (b) ->
        a.eval.call a, b
        return
      )(b)
      return

    camelCase: (a) ->
      a.replace(p, "ms-").replace q, r

    nodeName: (a, b) ->
      a.nodeName and a.nodeName.toLowerCase() is b.toLowerCase()

    each: (a, b, c) ->
      d = undefined
      e = 0
      f = a.length
      g = s(a)
      if c
        if g
          while f > e
            break  if d = b.apply(a[e], c)
            d is not 1
            e++
        else
          for e of a
            continue
      else if g
        while f > e
          break  if d = b.call(a[e], e, a[e])
          d is not 1
          e++
      else
        for e of a
          continue
      a

    trim: (if k and not k.call("﻿ ") then (a) ->
      (if null is a then "" else k.call(a))
     else (a) ->
      (if null is a then "" else (a + "").replace(o, ""))
    )
    makeArray: (a, b) ->
      c = b or []
      null isnt a and ((if s(Object(a)) then n.merge(c, (if "string" is typeof a then [a] else a)) else f.call(c, a)))
      c

    inArray: (a, b, c) ->
      d = undefined
      if b
        return g.call(b, a, c)  if g
        d = b.length
        c = (if c then (if 0 > c then Math.max(0, d + c) else c) else 0)

        while d > c
          return c  if c of b and b[c] is a
          c++
      -1

    merge: (a, b) ->
      c = +b.length
      d = 0
      e = a.length
      a[e++] = b[d++]  while c > d
      a[e++] = b[d++]  while undefined isnt b[d]  if c isnt c
      a.length = e
      a

    grep: (a, b, c) ->
      d = undefined
      e = []
      f = 0
      g = a.length
      h = not c

      while g > f
        d = not b(a[f], f)
        d isnt h and e.push(a[f])
        f++
      e

    map: (a, b, c) ->
      d = undefined
      f = 0
      g = a.length
      h = s(a)
      i = []
      if h
        while g > f
          d = b(a[f], f, c)
          null isnt d and i.push(d)
          f++
      else
        for f of a
          continue
      e.apply [], i

    guid: 1
    proxy: (a, b) ->
      c = undefined
      e = undefined
      f = undefined
      "string" is typeof b and (f = a[b]
      b = a
      a = f
      )
      (if n.isFunction(a) then (c = d.call(arguments_, 2)
      e = ->
        a.apply b or this, c.concat(d.call(arguments_))

      e.guid = a.guid = a.guid or n.guid++
      e
      ) else undefined)

    now: ->
      +new Date

    support: l
  )
  n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), (a, b) ->
    h["[object " + b + "]"] = b.toLowerCase()
    return
  )

  t = (a) ->
    db = (a, b, d, e) ->
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      m = undefined
      p = undefined
      q = undefined
      u = undefined
      v = undefined
      return d  if ((if b then b.ownerDocument or b else t)) isnt l and k(b)
      b = b or l
      d = d or []
      not a or "string" isnt typeof a

      return []  if 1 isnt (i = b.nodeType) and 9 isnt i
      if n and not e
        if f = Z.exec(a)
          if h = f[1]
            if 9 is i
              return d  if g = b.getElementById(h)
              not g or not g.parentNode

              if g.id is h
                return d.push(g)
                d
            else if b.ownerDocument and (g = b.ownerDocument.getElementById(h)) and r(b, g) and g.id is h
              return d.push(g)
              d
          else
            if f[2]
              return G.apply(d, b.getElementsByTagName(a))
              d
            if (h = f[3]) and c.getElementsByClassName and b.getElementsByClassName
              return G.apply(d, b.getElementsByClassName(h))
              d
        if c.qsa and (not o or not o.test(a))
          if q = p = s
          u = b
          v = 9 is i and a
          1 is i and "object" isnt b.nodeName.toLowerCase()
            m = ob(a)
            (if (p = b.getAttribute("id")) then q = p.replace(_, "\\$&") else b.setAttribute("id", q))
            q = "[id='" + q + "'] "
            j = m.length

            m[j] = q + pb(m[j])  while j--
            u = $.test(a) and mb(b.parentNode) or b
            v = m.join(",")
          if v
            try
              return G.apply(d, u.querySelectorAll(v))
              d
            finally
              p or b.removeAttribute("id")
      xb a.replace(P, "$1"), b, d, e
    eb = ->
      b = (c, e) ->
        a.push(c + " ") > d.cacheLength and delete b[a.shift()]

        b[c + " "] = e
      a = []
      b
    fb = (a) ->
      a[s] = not 0
      a
    gb = (a) ->
      b = l.createElement("div")
      try
        return !!a(b)
      catch c
        return not 1
      finally
        b.parentNode and b.parentNode.removeChild(b)
        b = null
      return
    hb = (a, b) ->
      c = a.split("|")
      e = a.length
      d.attrHandle[c[e]] = b  while e--
      return
    ib = (a, b) ->
      c = b and a
      d = c and 1 is a.nodeType and 1 is b.nodeType and (~b.sourceIndex or B) - (~a.sourceIndex or B)
      return d  if d
      return -1  if c is b  while c = c.nextSibling  if c
      (if a then 1 else -1)
    jb = (a) ->
      (b) ->
        c = b.nodeName.toLowerCase()
        "input" is c and b.type is a
    kb = (a) ->
      (b) ->
        c = b.nodeName.toLowerCase()
        ("input" is c or "button" is c) and b.type is a
    lb = (a) ->
      fb (b) ->
        b = +b
        fb((c, d) ->
          e = undefined
          f = a([], c.length, b)
          g = f.length
          c[e = f[g]] and (c[e] = not (d[e] = c[e]))  while g--
          return
        )

    mb = (a) ->
      a and typeof a.getElementsByTagName isnt A and a
    nb = ->
    ob = (a, b) ->
      c = undefined
      e = undefined
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      k = x[a + " "]
      return (if b then 0 else k.slice(0))  if k
      h = a
      i = []
      j = d.preFilter

      while h
        (not c or (e = Q.exec(h))) and (e and (h = h.slice(e[0].length) or h)
        i.push(f = [])
        )
        c = not 1
        (e = R.exec(h)) and (c = e.shift()
        f.push(
          value: c
          type: e[0].replace(P, " ")
        )
        h = h.slice(c.length)
        )

        for g of d.filter
          continue
        break  unless c
      (if b then h.length else (if h then db.error(a) else x(a, i).slice(0)))
    pb = (a) ->
      b = 0
      c = a.length
      d = ""

      while c > b
        d += a[b].value
        b++
      d
    qb = (a, b, c) ->
      d = b.dir
      e = c and "parentNode" is d
      f = v++
      (if b.first then (b, c, f) ->
        return a(b, c, f)  if 1 is b.nodeType or e  while b = b[d]
        return
       else (b, c, g) ->
        h = undefined
        i = undefined
        j = [
          u
          f
        ]
        if g
          return not 0  if (1 is b.nodeType or e) and a(b, c, g)  while b = b[d]
        else
          while b = b[d]
            if 1 is b.nodeType or e
              return j[2] = h[2]  if i = b[s] or (b[s] = {})
              (h = i[d]) and h[0] is u and h[1] is f

              return not 0  if i[d] = j
              j[2] = a(b, c, g)
        return
      )
    rb = (a) ->
      (if a.length > 1 then (b, c, d) ->
        e = a.length
        return not 1  unless a[e](b, c, d)  while e--
        not 0
       else a[0])
    sb = (a, b, c, d, e) ->
      f = undefined
      g = []
      h = 0
      i = a.length
      j = null isnt b

      while i > h
        (f = a[h]) and (not c or c(f, d, e)) and (g.push(f)
        j and b.push(h)
        )
        h++
      g
    tb = (a, b, c, d, e, f) ->
      d and not d[s] and (d = tb(d))
      e and not e[s] and (e = tb(e, f))
      fb((f, g, h, i) ->
        j = undefined
        k = undefined
        l = undefined
        m = []
        n = []
        o = g.length
        p = f or wb(b or "*", (if h.nodeType then [h] else h), [])
        q = (if not a or not f and b then p else sb(p, m, a, h, i))
        r = (if c then (if e or ((if f then a else o or d)) then [] else g) else q)
        if c and c(q, r, h, i)
        d
          j = sb(r, n)
          d(j, [], h, i)
          k = j.length

          (l = j[k]) and (r[n[k]] = not (q[n[k]] = l))  while k--
        if f
          if e or a
            if e
              j = []
              k = r.length

              (l = r[k]) and j.push(q[k] = l)  while k--
              e null, r = [], j, i
            k = r.length
            (l = r[k]) and (j = (if e then I.call(f, l) else m[k])) > -1 and (f[j] = not (g[j] = l))  while k--
        else
          r = sb((if r is g then r.splice(o, r.length) else r))
          (if e then e(null, g, r, i) else G.apply(g, r))
        return
      )
    ub = (a) ->
      b = undefined
      c = undefined
      e = undefined
      f = a.length
      g = d.relative[a[0].type]
      i = g or d.relative[" "]
      j = (if g then 1 else 0)
      k = qb((a) ->
        a is b
      , i, not 0)
      l = qb((a) ->
        I.call(b, a) > -1
      , i, not 0)
      m = [(a, c, d) ->
        not g and (d or c isnt h) or ((if (b = c).nodeType then k(a, c, d) else l(a, c, d)))
      ]

      while f > j
        if c = d.relative[a[j].type]
          m = [qb(rb(m), c)]
        else
          if c = d.filter[a[j].type].apply(null, a[j].matches)
          c[s]
            e = ++j
            while f > e
              break  if d.relative[a[e].type]
              e++
            return tb(j > 1 and rb(m), j > 1 and pb(a.slice(0, j - 1).concat(value: (if " " is a[j - 2].type then "*" else ""))).replace(P, "$1"), c, e > j and ub(a.slice(j, e)), f > e and ub(a = a.slice(e)), f > e and pb(a))
          m.push c
        j++
      rb m
    vb = (a, b) ->
      c = b.length > 0
      e = a.length > 0
      f = (f, g, i, j, k) ->
        m = undefined
        n = undefined
        o = undefined
        p = 0
        q = "0"
        r = f and []
        s = []
        t = h
        v = f or e and d.find.TAG("*", k)
        w = u += (if null is t then 1 else Math.random() or .1)
        x = v.length
        k and (h = g isnt l and g)
        while q isnt x and null isnt (m = v[q])
          if e and m
            n = 0
            while o = a[n++]
              if o(m, g, i)
                j.push m
                break
            k and (u = w)
          c and ((m = not o and m) and p--
          f and r.push(m)
          )
          q++
        if p += q
        c and q isnt p
          n = 0
          o r, s, g, i  while o = b[n++]
          if f
            r[q] or s[q] or (s[q] = E.call(j))  while q--  if p > 0
            s = sb(s)
          G.apply(j, s)
          k and not f and s.length > 0 and p + b.length > 1 and db.uniqueSort(j)
        k and (u = w
        h = t
        )
        r

      (if c then fb(f) else f)
    wb = (a, b, c) ->
      d = 0
      e = b.length

      while e > d
        db a, b[d], c
        d++
      c
    xb = (a, b, e, f) ->
      h = undefined
      i = undefined
      j = undefined
      k = undefined
      l = undefined
      m = ob(a)
      if not f and 1 is m.length
        if i = m[0] = m[0].slice(0)
        i.length > 2 and "ID" is (j = i[0]).type and c.getById and 9 is b.nodeType and n and d.relative[i[1].type]
          return e  if b = (d.find.ID(j.matches[0].replace(ab, bb), b) or [])[0]
          not b

          a = a.slice(i.shift().value.length)
        h = (if V.needsContext.test(a) then 0 else i.length)
        while h--
          break  if j = i[h]
          d.relative[k = j.type]

          if (l = d.find[k]) and (f = l(j.matches[0].replace(ab, bb), $.test(i[0].type) and mb(b.parentNode) or b))
            if i.splice(h, 1)
            a = f.length and pb(i)
            not a
              return G.apply(e, f)
              e
            break
      g(a, m)(f, b, not n, e, $.test(a) and mb(b.parentNode) or b)
      e
    b = undefined
    c = undefined
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = undefined
    i = undefined
    j = undefined
    k = undefined
    l = undefined
    m = undefined
    n = undefined
    o = undefined
    p = undefined
    q = undefined
    r = undefined
    s = "sizzle" + -new Date
    t = a.document
    u = 0
    v = 0
    w = eb()
    x = eb()
    y = eb()
    z = (a, b) ->
      a is b and (j = not 0)
      0

    A = "undefined"
    B = 1 << 31
    C = {}.hasOwnProperty
    D = []
    E = D.pop
    F = D.push
    G = D.push
    H = D.slice
    I = D.indexOf or (a) ->
      b = 0
      c = @length

      while c > b
        return b  if this[b] is a
        b++
      -1

    J = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped"
    K = "[\\x20\\t\\r\\n\\f]"
    L = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+"
    M = L.replace("w", "w#")
    N = "\\[" + K + "*(" + L + ")" + K + "*(?:([*^$|!~]?=)" + K + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + M + ")|)|)" + K + "*\\]"
    O = ":(" + L + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + N.replace(3, 8) + ")*)|.*)\\)|)"
    P = new RegExp("^" + K + "+|((?:^|[^\\\\])(?:\\\\.)*)" + K + "+$", "g")
    Q = new RegExp("^" + K + "*," + K + "*")
    R = new RegExp("^" + K + "*([>+~]|" + K + ")" + K + "*")
    S = new RegExp("=" + K + "*([^\\]'\"]*?)" + K + "*\\]", "g")
    T = new RegExp(O)
    U = new RegExp("^" + M + "$")
    V =
      ID: new RegExp("^#(" + L + ")")
      CLASS: new RegExp("^\\.(" + L + ")")
      TAG: new RegExp("^(" + L.replace("w", "w*") + ")")
      ATTR: new RegExp("^" + N)
      PSEUDO: new RegExp("^" + O)
      CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + K + "*(even|odd|(([+-]|)(\\d*)n|)" + K + "*(?:([+-]|)" + K + "*(\\d+)|))" + K + "*\\)|)", "i")
      bool: new RegExp("^(?:" + J + ")$", "i")
      needsContext: new RegExp("^" + K + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + K + "*((?:-\\d)?\\d*)" + K + "*\\)|)(?=[^-]|$)", "i")

    W = /^(?:input|select|textarea|button)$/i
    X = /^h\d$/i
    Y = /^[^{]+\{\s*\[native \w/
    Z = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/
    $ = /[+~]/
    _ = /'|\\/g
    ab = new RegExp("\\\\([\\da-f]{1,6}" + K + "?|(" + K + ")|.)", "ig")
    bb = (a, b, c) ->
      d = "0x" + b - 65536
      (if d isnt d or c then b else (if 0 > d then String.fromCharCode(d + 65536) else String.fromCharCode(d >> 10 | 55296, 1023 & d | 56320)))

    try
      G.apply(D = H.call(t.childNodes), t.childNodes)
      D[t.childNodes.length].nodeType
    catch cb
      G = apply: (if D.length then (a, b) ->
        F.apply a, H.call(b)
        return
       else (a, b) ->
        c = a.length
        d = 0
          while a[c++] = b[d++]
        a.length = c - 1
        return
      )
    c = db.support = {}
    f = db.isXML = (a) ->
      b = a and (a.ownerDocument or a).documentElement
      (if b then "HTML" isnt b.nodeName else not 1)

    k = db.setDocument = (a) ->
      b = undefined
      e = (if a then a.ownerDocument or a else t)
      g = e.defaultView
      (if e isnt l and 9 is e.nodeType and e.documentElement then (l = e
      m = e.documentElement
      n = not f(e)
      g and g isnt g.top and ((if g.addEventListener then g.addEventListener("unload", ->
        k()
        return
      , not 1) else g.attachEvent and g.attachEvent("onunload", ->
        k()
        return
      )))
      c.attributes = gb((a) ->
        a.className = "i"
        not a.getAttribute("className")
      )
      c.getElementsByTagName = gb((a) ->
        a.appendChild(e.createComment(""))
        not a.getElementsByTagName("*").length
      )
      c.getElementsByClassName = Y.test(e.getElementsByClassName) and gb((a) ->
        a.innerHTML = "<div class='a'></div><div class='a i'></div>"
        a.firstChild.className = "i"
        2 is a.getElementsByClassName("i").length
      )
      c.getById = gb((a) ->
        m.appendChild(a).id = s
        not e.getElementsByName or not e.getElementsByName(s).length
      )
      (if c.getById then (d.find.ID = (a, b) ->
        if typeof b.getElementById isnt A and n
          c = b.getElementById(a)
          (if c and c.parentNode then [c] else [])

      d.filter.ID = (a) ->
        b = a.replace(ab, bb)
        (a) ->
          a.getAttribute("id") is b

      ) else (delete d.find.ID

      d.filter.ID = (a) ->
        b = a.replace(ab, bb)
        (a) ->
          c = typeof a.getAttributeNode isnt A and a.getAttributeNode("id")
          c and c.value is b

      ))
      d.find.TAG = (if c.getElementsByTagName then (a, b) ->
        (if typeof b.getElementsByTagName isnt A then b.getElementsByTagName(a) else undefined)
       else (a, b) ->
        c = undefined
        d = []
        e = 0
        f = b.getElementsByTagName(a)
        if "*" is a
          1 is c.nodeType and d.push(c)  while c = f[e++]
          return d
        f
      )
      d.find.CLASS = c.getElementsByClassName and (a, b) ->
        (if typeof b.getElementsByClassName isnt A and n then b.getElementsByClassName(a) else undefined)

      p = []
      o = []
      (c.qsa = Y.test(e.querySelectorAll)) and (gb((a) ->
        a.innerHTML = "<select t=''><option selected=''></option></select>"
        a.querySelectorAll("[t^='']").length and o.push("[*^$]=" + K + "*(?:''|\"\")")
        a.querySelectorAll("[selected]").length or o.push("\\[" + K + "*(?:value|" + J + ")")
        a.querySelectorAll(":checked").length or o.push(":checked")

        return
      )
      gb((a) ->
        b = e.createElement("input")
        b.setAttribute("type", "hidden")
        a.appendChild(b).setAttribute("name", "D")
        a.querySelectorAll("[name=d]").length and o.push("name" + K + "*[*^$|!~]?=")
        a.querySelectorAll(":enabled").length or o.push(":enabled", ":disabled")
        a.querySelectorAll("*,:x")
        o.push(",.*:")

        return
      )
      )
      (c.matchesSelector = Y.test(q = m.webkitMatchesSelector or m.mozMatchesSelector or m.oMatchesSelector or m.msMatchesSelector)) and gb((a) ->
        c.disconnectedMatch = q.call(a, "div")
        q.call(a, "[s!='']:x")
        p.push("!=", O)

        return
      )
      o = o.length and new RegExp(o.join("|"))
      p = p.length and new RegExp(p.join("|"))
      b = Y.test(m.compareDocumentPosition)
      r = (if b or Y.test(m.contains) then (a, b) ->
        c = (if 9 is a.nodeType then a.documentElement else a)
        d = b and b.parentNode
        a is d or not (not d or 1 isnt d.nodeType or not ((if c.contains then c.contains(d) else a.compareDocumentPosition and 16 & a.compareDocumentPosition(d))))
       else (a, b) ->
        return not 0  if b is a  while b = b.parentNode  if b
        not 1
      )
      z = (if b then (a, b) ->
        if a is b
          return j = not 0
          0
        d = not a.compareDocumentPosition - not b.compareDocumentPosition
        (if d then d else (d = (if (a.ownerDocument or a) is (b.ownerDocument or b) then a.compareDocumentPosition(b) else 1)
        (if 1 & d or not c.sortDetached and b.compareDocumentPosition(a) is d then (if a is e or a.ownerDocument is t and r(t, a) then -1 else (if b is e or b.ownerDocument is t and r(t, b) then 1 else (if i then I.call(i, a) - I.call(i, b) else 0))) else (if 4 & d then -1 else 1))
        ))
       else (a, b) ->
        if a is b
          return j = not 0
          0
        c = undefined
        d = 0
        f = a.parentNode
        g = b.parentNode
        h = [a]
        k = [b]
        return (if a is e then -1 else (if b is e then 1 else (if f then -1 else (if g then 1 else (if i then I.call(i, a) - I.call(i, b) else 0)))))  if not f or not g
        return ib(a, b)  if f is g
        c = a
        h.unshift c  while c = c.parentNode
        c = b
        k.unshift c  while c = c.parentNode
        d++  while h[d] is k[d]
        (if d then ib(h[d], k[d]) else (if h[d] is t then -1 else (if k[d] is t then 1 else 0)))
      )
      e
      ) else l)

    db.matches = (a, b) ->
      db a, null, null, b

    db.matchesSelector = (a, b) ->
      if (a.ownerDocument or a) isnt l and k(a)
      b = b.replace(S, "='$1']")
      not (not c.matchesSelector or not n or p and p.test(b) or o and o.test(b))
        try
          d = q.call(a, b)
          return d  if d or c.disconnectedMatch or a.document and 11 isnt a.document.nodeType
      db(b, l, null, [a]).length > 0

    db.contains = (a, b) ->
      (a.ownerDocument or a) isnt l and k(a)
      r(a, b)

    db.attr = (a, b) ->
      (a.ownerDocument or a) isnt l and k(a)
      e = d.attrHandle[b.toLowerCase()]
      f = (if e and C.call(d.attrHandle, b.toLowerCase()) then e(a, b, not n) else undefined)
      (if undefined isnt f then f else (if c.attributes or not n then a.getAttribute(b) else (if (f = a.getAttributeNode(b)) and f.specified then f.value else null)))

    db.error = (a) ->
      throw new Error("Syntax error, unrecognized expression: " + a)return

    db.uniqueSort = (a) ->
      b = undefined
      d = []
      e = 0
      f = 0
      if j = not c.detectDuplicates
      i = not c.sortStable and a.slice(0)
      a.sort(z)
      j
        b is a[f] and (e = d.push(f))  while b = a[f++]
        a.splice d[e], 1  while e--
      i = null
      a

    e = db.getText = (a) ->
      b = undefined
      c = ""
      d = 0
      f = a.nodeType
      if f
        if 1 is f or 9 is f or 11 is f
          return a.textContent  if "string" is typeof a.textContent
          a = a.firstChild
          while a
            c += e(a)
            a = a.nextSibling
        else return a.nodeValue  if 3 is f or 4 is f
      else
        c += e(b)  while b = a[d++]
      c

    d = db.selectors =
      cacheLength: 50
      createPseudo: fb
      match: V
      attrHandle: {}
      find: {}
      relative:
        ">":
          dir: "parentNode"
          first: not 0

        " ":
          dir: "parentNode"

        "+":
          dir: "previousSibling"
          first: not 0

        "~":
          dir: "previousSibling"

      preFilter:
        ATTR: (a) ->
          a[1] = a[1].replace(ab, bb)
          a[3] = (a[4] or a[5] or "").replace(ab, bb)
          "~=" is a[2] and (a[3] = " " + a[3] + " ")
          a.slice(0, 4)

        CHILD: (a) ->
          a[1] = a[1].toLowerCase()
          (if "nth" is a[1].slice(0, 3) then (a[3] or db.error(a[0])
          a[4] = +((if a[4] then a[5] + (a[6] or 1) else 2 * ("even" is a[3] or "odd" is a[3])))
          a[5] = +(a[7] + a[8] or "odd" is a[3])
          ) else a[3] and db.error(a[0]))
          a

        PSEUDO: (a) ->
          b = undefined
          c = not a[5] and a[2]
          (if V.CHILD.test(a[0]) then null else ((if a[3] and undefined isnt a[4] then a[2] = a[4] else c and T.test(c) and (b = ob(c, not 0)) and (b = c.indexOf(")", c.length - b) - c.length) and (a[0] = a[0].slice(0, b)
          a[2] = c.slice(0, b)
          ))
          a.slice(0, 3)
          ))

      filter:
        TAG: (a) ->
          b = a.replace(ab, bb).toLowerCase()
          (if "*" is a then ->
            not 0
           else (a) ->
            a.nodeName and a.nodeName.toLowerCase() is b
          )

        CLASS: (a) ->
          b = w[a + " "]
          b or (b = new RegExp("(^|" + K + ")" + a + "(" + K + "|$)")) and w(a, (a) ->
            b.test "string" is typeof a.className and a.className or typeof a.getAttribute isnt A and a.getAttribute("class") or ""
          )

        ATTR: (a, b, c) ->
          (d) ->
            e = db.attr(d, a)
            (if null is e then "!=" is b else (if b then (e += ""
            (if "=" is b then e is c else (if "!=" is b then e isnt c else (if "^=" is b then c and 0 is e.indexOf(c) else (if "*=" is b then c and e.indexOf(c) > -1 else (if "$=" is b then c and e.slice(-c.length) is c else (if "~=" is b then (" " + e + " ").indexOf(c) > -1 else (if "|=" is b then e is c or e.slice(0, c.length + 1) is c + "-" else not 1)))))))
            ) else not 0))

        CHILD: (a, b, c, d, e) ->
          f = "nth" isnt a.slice(0, 3)
          g = "last" isnt a.slice(-4)
          h = "of-type" is b
          (if 1 is d and 0 is e then (a) ->
            !!a.parentNode
           else (b, c, i) ->
            j = undefined
            k = undefined
            l = undefined
            m = undefined
            n = undefined
            o = undefined
            p = (if f isnt g then "nextSibling" else "previousSibling")
            q = b.parentNode
            r = h and b.nodeName.toLowerCase()
            t = not i and not h
            if q
              if f
                while p
                  l = b
                  return not 1  if (if h then l.nodeName.toLowerCase() is r else 1 is l.nodeType)  while l = l[p]
                  o = p = "only" is a and not o and "nextSibling"
                return not 0
              if o = [(if g then q.firstChild else q.lastChild)]
              g and t
                k = q[s] or (q[s] = {})
                j = k[a] or []
                n = j[0] is u and j[1]
                m = j[0] is u and j[2]
                l = n and q.childNodes[n]

                while l = ++n and l and l[p] or (m = n = 0) or o.pop()
                  if 1 is l.nodeType and ++m and l is b
                    k[a] = [
                      u
                      n
                      m
                    ]
                    break
              else if t and (j = (b[s] or (b[s] = {}))[a]) and j[0] is u
                m = j[1]
              else
                while l = ++n and l and l[p] or (m = n = 0) or o.pop()
                  break  if ((if h then l.nodeName.toLowerCase() is r else 1 is l.nodeType)) and ++m and (t and ((l[s] or (l[s] = {}))[a] = [
                    u
                    m
                  ])
                  l is b
                  )
              m -= e
              m is d or m % d is 0 and m / d >= 0
          )

        PSEUDO: (a, b) ->
          c = undefined
          e = d.pseudos[a] or d.setFilters[a.toLowerCase()] or db.error("unsupported pseudo: " + a)
          (if e[s] then e(b) else (if e.length > 1 then (c = [
            a
            a
            ""
            b
          ]
          (if d.setFilters.hasOwnProperty(a.toLowerCase()) then fb((a, c) ->
            d = undefined
            f = e(a, b)
            g = f.length
            while g--
              d = I.call(a, f[g])
              a[d] = not (c[d] = f[g])
            return
          ) else (a) ->
            e a, 0, c
          )
          ) else e))

      pseudos:
        not: fb((a) ->
          b = []
          c = []
          d = g(a.replace(P, "$1"))
          (if d[s] then fb((a, b, c, e) ->
            f = undefined
            g = d(a, null, e, [])
            h = a.length
            (f = g[h]) and (a[h] = not (b[h] = f))  while h--
            return
          ) else (a, e, f) ->
            b[0] = a
            d(b, null, f, c)
            not c.pop()
          )
        )
        has: fb((a) ->
          (b) ->
            db(a, b).length > 0
        )
        contains: fb((a) ->
          (b) ->
            (b.textContent or b.innerText or e(b)).indexOf(a) > -1
        )
        lang: fb((a) ->
          U.test(a or "") or db.error("unsupported lang: " + a)
          a = a.replace(ab, bb).toLowerCase()
          (b) ->
            c = undefined
            loop
              if c = (if n then b.lang else b.getAttribute("xml:lang") or b.getAttribute("lang"))
                return c = c.toLowerCase()
                c is a or 0 is c.indexOf(a + "-")
              break unless (b = b.parentNode) and 1 is b.nodeType
            not 1
        )
        target: (b) ->
          c = a.location and a.location.hash
          c and c.slice(1) is b.id

        root: (a) ->
          a is m

        focus: (a) ->
          a is l.activeElement and (not l.hasFocus or l.hasFocus()) and !!(a.type or a.href or ~a.tabIndex)

        enabled: (a) ->
          a.disabled is not 1

        disabled: (a) ->
          a.disabled is not 0

        checked: (a) ->
          b = a.nodeName.toLowerCase()
          "input" is b and !!a.checked or "option" is b and !!a.selected

        selected: (a) ->
          a.parentNode and a.parentNode.selectedIndex
          a.selected is not 0

        empty: (a) ->
          a = a.firstChild
          while a
            return not 1  if a.nodeType < 6
            a = a.nextSibling
          not 0

        parent: (a) ->
          not d.pseudos.empty(a)

        header: (a) ->
          X.test a.nodeName

        input: (a) ->
          W.test a.nodeName

        button: (a) ->
          b = a.nodeName.toLowerCase()
          "input" is b and "button" is a.type or "button" is b

        text: (a) ->
          b = undefined
          "input" is a.nodeName.toLowerCase() and "text" is a.type and (null is (b = a.getAttribute("type")) or "text" is b.toLowerCase())

        first: lb(->
          [0]
        )
        last: lb((a, b) ->
          [b - 1]
        )
        eq: lb((a, b, c) ->
          [(if 0 > c then c + b else c)]
        )
        even: lb((a, b) ->
          c = 0

          while b > c
            a.push c
            c += 2
          a
        )
        odd: lb((a, b) ->
          c = 1

          while b > c
            a.push c
            c += 2
          a
        )
        lt: lb((a, b, c) ->
          d = (if 0 > c then c + b else c)

          while --d >= 0
            a.push d
          a
        )
        gt: lb((a, b, c) ->
          d = (if 0 > c then c + b else c)

          while ++d < b
            a.push d
          a
        )

    d.pseudos.nth = d.pseudos.eq

    for b of
      radio: not 0
      checkbox: not 0
      file: not 0
      password: not 0
      image: not 0
      continue
    for b of
      submit: not 0
      reset: not 0
      continue
    nb:: = d.filters = d.pseudos
    d.setFilters = new nb

    g = db.compile = (a, b) ->
      c = undefined
      d = []
      e = []
      f = y[a + " "]
      unless f
        b or (b = ob(a))
        c = b.length

        while c--
          f = ub(b[c])
          (if f[s] then d.push(f) else e.push(f))
        f = y(a, vb(e, d))
      f

    c.sortStable = s.split("").sort(z).join("") is s
    c.detectDuplicates = !!j
    k()
    c.sortDetached = gb((a) ->
      1 & a.compareDocumentPosition(l.createElement("div"))
    )
    gb((a) ->
      a.innerHTML = "<a href='#'></a>"
      "#" is a.firstChild.getAttribute("href")
    ) or hb("type|href|height|width", (a, b, c) ->
      (if c then undefined else a.getAttribute(b, (if "type" is b.toLowerCase() then 1 else 2)))
    )
    c.attributes and gb((a) ->
      a.innerHTML = "<input/>"
      a.firstChild.setAttribute("value", "")
      "" is a.firstChild.getAttribute("value")
    ) or hb("value", (a, b, c) ->
      (if c or "input" isnt a.nodeName.toLowerCase() then undefined else a.defaultValue)
    )
    gb((a) ->
      null is a.getAttribute("disabled")
    ) or hb(J, (a, b, c) ->
      d = undefined
      (if c then undefined else (if a[b] is not 0 then b.toLowerCase() else (if (d = a.getAttributeNode(b)) and d.specified then d.value else null)))
    )
    db
  (a)
  n.find = t
  n.expr = t.selectors
  n.expr[":"] = n.expr.pseudos
  n.unique = t.uniqueSort
  n.text = t.getText
  n.isXMLDoc = t.isXML
  n.contains = t.contains

  u = n.expr.match.needsContext
  v = /^<(\w+)\s*\/?>(?:<\/\1>|)$/
  w = /^.[^:#\[\.,]*$/
  n.filter = (a, b, c) ->
    d = b[0]
    c and (a = ":not(" + a + ")")
    (if 1 is b.length and 1 is d.nodeType then (if n.find.matchesSelector(d, a) then [d] else []) else n.find.matches(a, n.grep(b, (a) ->
      1 is a.nodeType
    )))

  n.fn.extend(
    find: (a) ->
      b = undefined
      c = []
      d = this
      e = d.length
      unless "string" is typeof a
        return @pushStack(n(a).filter(->
          b = 0
          while e > b
            return not 0  if n.contains(d[b], this)
            b++
          return
        ))
      b = 0
      while e > b
        n.find a, d[b], c
        b++
      c = @pushStack((if e > 1 then n.unique(c) else c))
      c.selector = (if @selector then @selector + " " + a else a)
      c

    filter: (a) ->
      @pushStack x(this, a or [], not 1)

    not: (a) ->
      @pushStack x(this, a or [], not 0)

    is: (a) ->
      !!x(this, (if "string" is typeof a and u.test(a) then n(a) else a or []), not 1).length
  )

  y = undefined
  z = a.document
  A = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/
  B = n.fn.init = (a, b) ->
    c = undefined
    d = undefined
    return this  unless a
    if "string" is typeof a
      return (if not b or b.jquery then (b or y).find(a) else @constructor(b).find(a))  if c = (if "<" is a.charAt(0) and ">" is a.charAt(a.length - 1) and a.length >= 3 then [
        null
        a
        null
      ] else A.exec(a))
      not c or not c[1] and b

      if c[1]
        if b = (if b instanceof n then b[0] else b)
        n.merge(this, n.parseHTML(c[1], (if b and b.nodeType then b.ownerDocument or b else z), not 0))
        v.test(c[1]) and n.isPlainObject(b)
          for c of b
            continue
        return this
      if d = z.getElementById(c[2])
      d and d.parentNode
        return y.find(a)  if d.id isnt c[2]
        @length = 1
        this[0] = d
      return @context = z
      @selector = a
      this
    (if a.nodeType then (@context = this[0] = a
    @length = 1
    this
    ) else (if n.isFunction(a) then (if "undefined" isnt typeof y.ready then y.ready(a) else a(n)) else (undefined isnt a.selector and (@selector = a.selector
    @context = a.context
    )
    n.makeArray(a, this)
    )))

  B:: = n.fn
  y = n(z)

  C = /^(?:parents|prev(?:Until|All))/
  D =
    children: not 0
    contents: not 0
    next: not 0
    prev: not 0

  n.extend(
    dir: (a, b, c) ->
      d = []
      e = a[b]
      while e and 9 isnt e.nodeType and (undefined is c or 1 isnt e.nodeType or not n(e).is(c))
        1 is e.nodeType and d.push(e)
        e = e[b]
      d

    sibling: (a, b) ->
      c = []

      while a
        1 is a.nodeType and a isnt b and c.push(a)
        a = a.nextSibling
      c
  )
  n.fn.extend(
    has: (a) ->
      b = undefined
      c = n(a, this)
      d = c.length
      @filter ->
        b = 0
        while d > b
          return not 0  if n.contains(this, c[b])
          b++
        return


    closest: (a, b) ->
      c = undefined
      d = 0
      e = @length
      f = []
      g = (if u.test(a) or "string" isnt typeof a then n(a, b or @context) else 0)

      while e > d
        c = this[d]
        while c and c isnt b
          if c.nodeType < 11 and ((if g then g.index(c) > -1 else 1 is c.nodeType and n.find.matchesSelector(c, a)))
            f.push c
            break
          c = c.parentNode
        d++
      @pushStack (if f.length > 1 then n.unique(f) else f)

    index: (a) ->
      (if a then (if "string" is typeof a then n.inArray(this[0], n(a)) else n.inArray((if a.jquery then a[0] else a), this)) else (if this[0] and this[0].parentNode then @first().prevAll().length else -1))

    add: (a, b) ->
      @pushStack n.unique(n.merge(@get(), n(a, b)))

    addBack: (a) ->
      @add (if null is a then @prevObject else @prevObject.filter(a))
  )

  n.each
    parent: (a) ->
      b = a.parentNode
      (if b and 11 isnt b.nodeType then b else null)

    parents: (a) ->
      n.dir a, "parentNode"

    parentsUntil: (a, b, c) ->
      n.dir a, "parentNode", c

    next: (a) ->
      E a, "nextSibling"

    prev: (a) ->
      E a, "previousSibling"

    nextAll: (a) ->
      n.dir a, "nextSibling"

    prevAll: (a) ->
      n.dir a, "previousSibling"

    nextUntil: (a, b, c) ->
      n.dir a, "nextSibling", c

    prevUntil: (a, b, c) ->
      n.dir a, "previousSibling", c

    siblings: (a) ->
      n.sibling (a.parentNode or {}).firstChild, a

    children: (a) ->
      n.sibling a.firstChild

    contents: (a) ->
      (if n.nodeName(a, "iframe") then a.contentDocument or a.contentWindow.document else n.merge([], a.childNodes))
  , (a, b) ->
    n.fn[a] = (c, d) ->
      e = n.map(this, b, c)
      "Until" isnt a.slice(-5) and (d = c)
      d and "string" is typeof d and (e = n.filter(d, e))
      @length > 1 and (D[a] or (e = n.unique(e))
      C.test(a) and (e = e.reverse())
      )
      @pushStack(e)

    return

  F = /\S+/g
  G = {}
  n.Callbacks = (a) ->
    a = (if "string" is typeof a then G[a] or H(a) else n.extend({}, a))
    b = undefined
    c = undefined
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = []
    i = not a.once and []
    j = (l) ->
      c = a.memory and l
      d = not 0
      f = g or 0
      g = 0
      e = h.length
      b = not 0

      while h and e > f
        if h[f].apply(l[0], l[1]) is not 1 and a.stopOnFalse
          c = not 1
          break
        f++
      b = not 1
      h and ((if i then i.length and j(i.shift()) else (if c then h = [] else k.disable())))

      return

    k =
      add: ->
        if h
          d = h.length
          not f = (b) ->
            n.each b, (b, c) ->
              d = n.type(c)
              (if "function" is d then a.unique and k.has(c) or h.push(c) else c and c.length and "string" isnt d and f(c))
              return

            return
          (arguments_)
          (if b then e = h.length else c and (g = d
          j(c)
          ))
        this

      remove: ->
        h and n.each(arguments_, (a, c) ->
          d = undefined
          while (d = n.inArray(c, h, d)) > -1
            h.splice(d, 1)
            b and (e >= d and e--
            f >= d and f--
            )
          return
        )
        this

      has: (a) ->
        (if a then n.inArray(a, h) > -1 else not (not h or not h.length))

      empty: ->
        h = []
        e = 0
        this

      disable: ->
        h = i = c = undefined
        this

      disabled: ->
        not h

      lock: ->
        i = undefined
        c or k.disable()
        this

      locked: ->
        not i

      fireWith: (a, c) ->
        not h or d and not i or (c = c or []
        c = [
          a
          (if c.slice then c.slice() else c)
        ]
        (if b then i.push(c) else j(c))
        )
        this

      fire: ->
        k.fireWith(this, arguments_)
        this

      fired: ->
        !!d

    k

  n.extend(
    Deferred: (a) ->
      b = [
        [
          "resolve"
          "done"
          n.Callbacks("once memory")
          "resolved"
        ]
        [
          "reject"
          "fail"
          n.Callbacks("once memory")
          "rejected"
        ]
        [
          "notify"
          "progress"
          n.Callbacks("memory")
        ]
      ]
      c = "pending"
      d =
        state: ->
          c

        always: ->
          e.done(arguments_).fail(arguments_)
          this

        then: ->
          a = arguments_
          n.Deferred((c) ->
            n.each(b, (b, f) ->
              g = n.isFunction(a[b]) and a[b]
              e[f[1]] ->
                a = g and g.apply(this, arguments_)
                (if a and n.isFunction(a.promise) then a.promise().done(c.resolve).fail(c.reject).progress(c.notify) else c[f[0] + "With"]((if this is d then c.promise() else this), (if g then [a] else arguments_)))
                return

              return
            )
            a = null

            return
          ).promise()

        promise: (a) ->
          (if null isnt a then n.extend(a, d) else d)

      e = {}
      d.pipe = d.then
      n.each(b, (a, f) ->
        g = f[2]
        h = f[3]
        d[f[1]] = g.add
        h and g.add(->
          c = h
          return
        , b[1 ^ a][2].disable, b[2][2].lock)
        e[f[0]] = ->
          e[f[0] + "With"]((if this is e then d else this), arguments_)
          this

        e[f[0] + "With"] = g.fireWith

        return
      )
      d.promise(e)
      a and a.call(e, e)
      e

    when: (a) ->
      b = 0
      c = d.call(arguments_)
      e = c.length
      f = (if 1 isnt e or a and n.isFunction(a.promise) then e else 0)
      g = (if 1 is f then a else n.Deferred())
      h = (a, b, c) ->
        (e) ->
          b[a] = this
          c[a] = (if arguments_.length > 1 then d.call(arguments_) else e)
          (if c is i then g.notifyWith(b, c) else --f or g.resolveWith(b, c))

          return

      i = undefined
      j = undefined
      k = undefined
      if e > 1
        i = new Array(e)
        j = new Array(e)
        k = new Array(e)

        while e > b
          (if c[b] and n.isFunction(c[b].promise) then c[b].promise().done(h(b, k, c)).fail(g.reject).progress(h(b, j, i)) else --f)
          b++
      f or g.resolveWith(k, c)
      g.promise()
  )

  I = undefined
  n.fn.ready = (a) ->
    n.ready.promise().done(a)
    this

  n.extend(
    isReady: not 1
    readyWait: 1
    holdReady: (a) ->
      (if a then n.readyWait++ else n.ready(not 0))
      return

    ready: (a) ->
      if (if a is not 0 then not --n.readyWait else not n.isReady)
        return setTimeout(n.ready)  unless z.body
        n.isReady = not 0
        a isnt not 0 and --n.readyWait > 0 or (I.resolveWith(z, [n])
        n.fn.trigger and n(z).trigger("ready").off("ready")
        )
      return
  )

  n.ready.promise = (b) ->
    unless I
      if I = n.Deferred()
      "complete" is z.readyState
        setTimeout n.ready
      else if z.addEventListener
        z.addEventListener("DOMContentLoaded", K, not 1)
        a.addEventListener("load", K, not 1)
      else
        z.attachEvent("onreadystatechange", K)
        a.attachEvent("onload", K)

        c = not 1
        try
          c = null is a.frameElement and z.documentElement
        c and c.doScroll and not e = ->
          unless n.isReady
            try
              c.doScroll "left"
            catch a
              return setTimeout(e, 50)
            J()
            n.ready()
          return
        ()
    I.promise b

  L = "undefined"
  M = undefined
  for M of n(l)
    continue
  l.ownLast = "0" isnt M
  l.inlineBlockNeedsLayout = not 1
  n(->
    a = undefined
    b = undefined
    c = z.getElementsByTagName("body")[0]
    c and (a = z.createElement("div")
    a.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px"
    b = z.createElement("div")
    c.appendChild(a).appendChild(b)
    typeof b.style.zoom isnt L and (b.style.cssText = "border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1"
    (l.inlineBlockNeedsLayout = 3 is b.offsetWidth) and (c.style.zoom = 1)
    )
    c.removeChild(a)
    a = b = null
    )
    return
  )
  ->
    a = z.createElement("div")
    if null is l.deleteExpando
      l.deleteExpando = not 0
      try
        delete a.test
      catch b
        l.deleteExpando = not 1
    a = null
    return
  ()
  n.acceptData = (a) ->
    b = n.noData[(a.nodeName + " ").toLowerCase()]
    c = +a.nodeType or 1
    (if 1 isnt c and 9 isnt c then not 1 else not b or b isnt not 0 and a.getAttribute("classid") is b)


  N = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/
  O = /([A-Z])/g
  n.extend(
    cache: {}
    noData:
      "applet ": not 0
      "embed ": not 0
      "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"

    hasData: (a) ->
      a = (if a.nodeType then n.cache[a[n.expando]] else a[n.expando])
      !!a and not Q(a)

    data: (a, b, c) ->
      R a, b, c

    removeData: (a, b) ->
      S a, b

    _data: (a, b, c) ->
      R a, b, c, not 0

    _removeData: (a, b) ->
      S a, b, not 0
  )
  n.fn.extend(
    data: (a, b) ->
      c = undefined
      d = undefined
      e = undefined
      f = this[0]
      g = f and f.attributes
      if undefined is a
        if @length and (e = n.data(f)
        1 is f.nodeType and not n._data(f, "parsedAttrs")
        )
          c = g.length
          while c--
            d = g[c].name
            0 is d.indexOf("data-") and (d = n.camelCase(d.slice(5))
            P(f, d, e[d])
            )
          n._data f, "parsedAttrs", not 0
        return e
      (if "object" is typeof a then @each(->
        n.data this, a
        return
      ) else (if arguments_.length > 1 then @each(->
        n.data this, a, b
        return
      ) else (if f then P(f, a, n.data(f, a)) else undefined)))

    removeData: (a) ->
      @each ->
        n.removeData this, a
        return

  )
  n.extend(
    queue: (a, b, c) ->
      d = undefined
      (if a then (b = (b or "fx") + "queue"
      d = n._data(a, b)
      c and ((if not d or n.isArray(c) then d = n._data(a, b, n.makeArray(c)) else d.push(c)))
      d or []
      ) else undefined)

    dequeue: (a, b) ->
      b = b or "fx"
      c = n.queue(a, b)
      d = c.length
      e = c.shift()
      f = n._queueHooks(a, b)
      g = ->
        n.dequeue a, b
        return

      "inprogress" is e and (e = c.shift()
      d--
      )
      e and ("fx" is b and c.unshift("inprogress")
      delete f.stop

      e.call(a, g, f)
      )
      not d and f and f.empty.fire()

      return

    _queueHooks: (a, b) ->
      c = b + "queueHooks"
      n._data(a, c) or n._data(a, c,
        empty: n.Callbacks("once memory").add(->
          n._removeData(a, b + "queue")
          n._removeData(a, c)

          return
        )
      )
  )
  n.fn.extend(
    queue: (a, b) ->
      c = 2
      "string" isnt typeof a and (b = a
      a = "fx"
      c--
      )
      (if arguments_.length < c then n.queue(this[0], a) else (if undefined is b then this else @each(->
        c = n.queue(this, a, b)
        n._queueHooks(this, a)
        "fx" is a and "inprogress" isnt c[0] and n.dequeue(this, a)

        return
      )))

    dequeue: (a) ->
      @each ->
        n.dequeue this, a
        return


    clearQueue: (a) ->
      @queue a or "fx", []

    promise: (a, b) ->
      c = undefined
      d = 1
      e = n.Deferred()
      f = this
      g = @length
      h = ->
        --d or e.resolveWith(f, [f])
        return

      "string" isnt typeof a and (b = a
      a = undefined
      )
      a = a or "fx"

      while g--
        c = n._data(f[g], a + "queueHooks")
        c and c.empty and (d++
        c.empty.add(h)
        )
      h()
      e.promise(b)
  )

  T = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source
  U = [
    "Top"
    "Right"
    "Bottom"
    "Left"
  ]
  V = (a, b) ->
    a = b or a
    "none" is n.css(a, "display") or not n.contains(a.ownerDocument, a)

  W = n.access = (a, b, c, d, e, f, g) ->
    h = 0
    i = a.length
    j = null is c
    if "object" is n.type(c)
      e = not 0
      for h of c
        continue
    else if undefined isnt d and (e = not 0
    n.isFunction(d) or (g = not 0)
    j and ((if g then (b.call(a, d)
    b = null
    ) else (j = b
    b = (a, b, c) ->
      j.call n(a), c

    )))
    b
    )
      while i > h
        b a[h], c, (if g then d else d.call(a[h], h, b(a[h], c)))
        h++
    (if e then a else (if j then b.call(a) else (if i then b(a[0], c) else f)))

  X = /^(?:checkbox|radio)$/i
  not ->
    a = z.createDocumentFragment()
    b = z.createElement("div")
    c = z.createElement("input")
    if b.setAttribute("className", "t")
    b.innerHTML = "  <link/><table></table><a href='/a'>a</a>"
    l.leadingWhitespace = 3 is b.firstChild.nodeType
    l.tbody = not b.getElementsByTagName("tbody").length
    l.htmlSerialize = !!b.getElementsByTagName("link").length
    l.html5Clone = "<:nav></:nav>" isnt z.createElement("nav").cloneNode(not 0).outerHTML
    c.type = "checkbox"
    c.checked = not 0
    a.appendChild(c)
    l.appendChecked = c.checked
    b.innerHTML = "<textarea>x</textarea>"
    l.noCloneChecked = !!b.cloneNode(not 0).lastChild.defaultValue
    a.appendChild(b)
    b.innerHTML = "<input type='radio' checked='checked' name='t'/>"
    l.checkClone = b.cloneNode(not 0).cloneNode(not 0).lastChild.checked
    l.noCloneEvent = not 0
    b.attachEvent and (b.attachEvent("onclick", ->
      l.noCloneEvent = not 1
      return
    )
    b.cloneNode(not 0).click()
    )
    null is l.deleteExpando
      l.deleteExpando = not 0
      try
        delete b.test
      catch d
        l.deleteExpando = not 1
    a = b = c = null
    return
  ()
  ->
    b = undefined
    c = undefined
    d = z.createElement("div")
    for b of
      submit: not 0
      change: not 0
      focusin: not 0
      continue
    d = null
    return
  ()

  Y = /^(?:input|select|textarea)$/i
  Z = /^key/
  $ = /^(?:mouse|contextmenu)|click/
  _ = /^(?:focusinfocus|focusoutblur)$/
  ab = /^([^.]*)(?:\.(.+)|)$/
  n.event =
    global: {}
    add: (a, b, c, d, e) ->
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      k = undefined
      l = undefined
      m = undefined
      o = undefined
      p = undefined
      q = undefined
      r = n._data(a)
      if r
        c.handler and (i = c
        c = i.handler
        e = i.selector
        )
        c.guid or (c.guid = n.guid++)
        (g = r.events) or (g = r.events = {})
        (k = r.handle) or (k = r.handle = (a) ->
          (if typeof n is L or a and n.event.triggered is a.type then undefined else n.event.dispatch.apply(k.elem, arguments_))

        k.elem = a
        )
        b = (b or "").match(F) or [""]
        h = b.length

        while h--
          f = ab.exec(b[h]) or []
          o = q = f[1]
          p = (f[2] or "").split(".").sort()
          o and (j = n.event.special[o] or {}
          o = ((if e then j.delegateType else j.bindType)) or o
          j = n.event.special[o] or {}
          l = n.extend(
            type: o
            origType: q
            data: d
            handler: c
            guid: c.guid
            selector: e
            needsContext: e and n.expr.match.needsContext.test(e)
            namespace: p.join(".")
          , i)
          (m = g[o]) or (m = g[o] = []
          m.delegateCount = 0
          j.setup and j.setup.call(a, d, p, k) isnt not 1 or ((if a.addEventListener then a.addEventListener(o, k, not 1) else a.attachEvent and a.attachEvent("on" + o, k)))
          )
          j.add and (j.add.call(a, l)
          l.handler.guid or (l.handler.guid = c.guid)
          )
          (if e then m.splice(m.delegateCount++, 0, l) else m.push(l))
          n.event.global[o] = not 0
          )
        a = null
      return

    remove: (a, b, c, d, e) ->
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      k = undefined
      l = undefined
      m = undefined
      o = undefined
      p = undefined
      q = undefined
      r = n.hasData(a) and n._data(a)
      if r and (k = r.events)
        b = (b or "").match(F) or [""]
        j = b.length

        while j--
          if h = ab.exec(b[j]) or []
          o = q = h[1]
          p = (h[2] or "").split(".").sort()
          o
            l = n.event.special[o] or {}
            o = ((if d then l.delegateType else l.bindType)) or o
            m = k[o] or []
            h = h[2] and new RegExp("(^|\\.)" + p.join("\\.(?:.*\\.|)") + "(\\.|$)")
            i = f = m.length

            while f--
              g = m[f]
              not e and q isnt g.origType or c and c.guid isnt g.guid or h and not h.test(g.namespace) or d and d isnt g.selector and ("**" isnt d or not g.selector) or (m.splice(f, 1)
              g.selector and m.delegateCount--
              l.remove and l.remove.call(a, g)
              )
            i and not m.length and (l.teardown and l.teardown.call(a, p, r.handle) isnt not 1 or n.removeEvent(a, o, r.handle)
            delete k[o]

            )
          else
            for o of k
              continue
        n.isEmptyObject(k) and (delete r.handle

        n._removeData(a, "events")
        )
      return

    trigger: (b, c, d, e) ->
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      k = undefined
      l = undefined
      m = undefined
      o = [d or z]
      p = (if j.call(b, "type") then b.type else b)
      q = (if j.call(b, "namespace") then b.namespace.split(".") else [])
      if h = l = d = d or z
      3 isnt d.nodeType and 8 isnt d.nodeType and not _.test(p + n.event.triggered) and (p.indexOf(".") >= 0 and (q = p.split(".")
      p = q.shift()
      q.sort()
      )
      g = p.indexOf(":") < 0 and "on" + p
      b = (if b[n.expando] then b else new n.Event(p, "object" is typeof b and b))
      b.isTrigger = (if e then 2 else 3)
      b.namespace = q.join(".")
      b.namespace_re = (if b.namespace then new RegExp("(^|\\.)" + q.join("\\.(?:.*\\.|)") + "(\\.|$)") else null)
      b.result = undefined
      b.target or (b.target = d)
      c = (if null is c then [b] else n.makeArray(c, [b]))
      k = n.event.special[p] or {}
      e or not k.trigger or k.trigger.apply(d, c) isnt not 1
      )
        if not e and not k.noBubble and not n.isWindow(d)
          i = k.delegateType or p
          _.test(i + p) or (h = h.parentNode)

          while h
            o.push(h)
            l = h
            h = h.parentNode
          l is (d.ownerDocument or z) and o.push(l.defaultView or l.parentWindow or a)
        m = 0
        while (h = o[m++]) and not b.isPropagationStopped()
          b.type = (if m > 1 then i else k.bindType or p)
          f = (n._data(h, "events") or {})[b.type] and n._data(h, "handle")
          f and f.apply(h, c)
          f = g and h[g]
          f and f.apply and n.acceptData(h) and (b.result = f.apply(h, c)
          b.result is not 1 and b.preventDefault()
          )
        if b.type = p
        not e and not b.isDefaultPrevented() and (not k._default or k._default.apply(o.pop(), c) is not 1) and n.acceptData(d) and g and d[p] and not n.isWindow(d)
          l = d[g]
          l and (d[g] = null)
          n.event.triggered = p

          try
            d[p]()
          n.event.triggered = undefined
          l and (d[g] = l)
        b.result

    dispatch: (a) ->
      a = n.event.fix(a)
      b = undefined
      c = undefined
      e = undefined
      f = undefined
      g = undefined
      h = []
      i = d.call(arguments_)
      j = (n._data(this, "events") or {})[a.type] or []
      k = n.event.special[a.type] or {}
      if i[0] = a
      a.delegateTarget = this
      not k.preDispatch or k.preDispatch.call(this, a) isnt not 1
        h = n.event.handlers.call(this, a, j)
        b = 0

        while (f = h[b++]) and not a.isPropagationStopped()
          a.currentTarget = f.elem
          g = 0

          while (e = f.handlers[g++]) and not a.isImmediatePropagationStopped()
            (not a.namespace_re or a.namespace_re.test(e.namespace)) and (a.handleObj = e
            a.data = e.data
            c = ((n.event.special[e.origType] or {}).handle or e.handler).apply(f.elem, i)
            undefined isnt c and (a.result = c) is not 1 and (a.preventDefault()
            a.stopPropagation()
            )
            )
        k.postDispatch and k.postDispatch.call(this, a)
        a.result

    handlers: (a, b) ->
      c = undefined
      d = undefined
      e = undefined
      f = undefined
      g = []
      h = b.delegateCount
      i = a.target
      if h and i.nodeType and (not a.button or "click" isnt a.type)
        while i isnt this
          if 1 is i.nodeType and (i.disabled isnt not 0 or "click" isnt a.type)
            e = []
            f = 0

            while h > f
              d = b[f]
              c = d.selector + " "
              undefined is e[c] and (e[c] = (if d.needsContext then n(c, this).index(i) >= 0 else n.find(c, this, null, [i]).length))
              e[c] and e.push(d)
              f++
            e.length and g.push(
              elem: i
              handlers: e
            )
          i = i.parentNode or this
      h < b.length and g.push(
        elem: this
        handlers: b.slice(h)
      )
      g

    fix: (a) ->
      return a  if a[n.expando]
      b = undefined
      c = undefined
      d = undefined
      e = a.type
      f = a
      g = @fixHooks[e]
      g or (@fixHooks[e] = g = (if $.test(e) then @mouseHooks else (if Z.test(e) then @keyHooks else {})))
      d = (if g.props then @props.concat(g.props) else @props)
      a = new n.Event(f)
      b = d.length

      while b--
        c = d[b]
        a[c] = f[c]
      a.target or (a.target = f.srcElement or z)
      3 is a.target.nodeType and (a.target = a.target.parentNode)
      a.metaKey = !!a.metaKey
      (if g.filter then g.filter(a, f) else a)

    props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" ")
    fixHooks: {}
    keyHooks:
      props: "char charCode key keyCode".split(" ")
      filter: (a, b) ->
        null is a.which and (a.which = (if null isnt b.charCode then b.charCode else b.keyCode))
        a

    mouseHooks:
      props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" ")
      filter: (a, b) ->
        c = undefined
        d = undefined
        e = undefined
        f = b.button
        g = b.fromElement
        null is a.pageX and null isnt b.clientX and (d = a.target.ownerDocument or z
        e = d.documentElement
        c = d.body
        a.pageX = b.clientX + (e and e.scrollLeft or c and c.scrollLeft or 0) - (e and e.clientLeft or c and c.clientLeft or 0)
        a.pageY = b.clientY + (e and e.scrollTop or c and c.scrollTop or 0) - (e and e.clientTop or c and c.clientTop or 0)
        )
        not a.relatedTarget and g and (a.relatedTarget = (if g is a.target then b.toElement else g))
        a.which or undefined is f or (a.which = (if 1 & f then 1 else (if 2 & f then 3 else (if 4 & f then 2 else 0))))
        a

    special:
      load:
        noBubble: not 0

      focus:
        trigger: ->
          if this isnt db() and @focus
            try
              return @focus()
              not 1
          return

        delegateType: "focusin"

      blur:
        trigger: ->
          (if this is db() and @blur then (@blur()
          not 1
          ) else undefined)

        delegateType: "focusout"

      click:
        trigger: ->
          (if n.nodeName(this, "input") and "checkbox" is @type and @click then (@click()
          not 1
          ) else undefined)

        _default: (a) ->
          n.nodeName a.target, "a"

      beforeunload:
        postDispatch: (a) ->
          undefined isnt a.result and (a.originalEvent.returnValue = a.result)
          return

    simulate: (a, b, c, d) ->
      e = n.extend(new n.Event, c,
        type: a
        isSimulated: not 0
        originalEvent: {}
      )
      (if d then n.event.trigger(e, null, b) else n.event.dispatch.call(b, e))
      e.isDefaultPrevented() and c.preventDefault()

      return

  n.removeEvent = (if z.removeEventListener then (a, b, c) ->
    a.removeEventListener and a.removeEventListener(b, c, not 1)
    return
   else (a, b, c) ->
    d = "on" + b
    a.detachEvent and (typeof a[d] is L and (a[d] = null)
    a.detachEvent(d, c)
    )
    return
  )
  n.Event = (a, b) ->
    (if this instanceof n.Event then ((if a and a.type then (@originalEvent = a
    @type = a.type
    @isDefaultPrevented = (if a.defaultPrevented or undefined is a.defaultPrevented and (a.returnValue is not 1 or a.getPreventDefault and a.getPreventDefault()) then bb else cb)
    ) else @type = a)
    b and n.extend(this, b)
    @timeStamp = a and a.timeStamp or n.now()
    undefined
    ) else new n.Event(a, b))

  n.Event:: =
    isDefaultPrevented: cb
    isPropagationStopped: cb
    isImmediatePropagationStopped: cb
    preventDefault: ->
      a = @originalEvent
      @isDefaultPrevented = bb
      a and ((if a.preventDefault then a.preventDefault() else a.returnValue = not 1))

      return

    stopPropagation: ->
      a = @originalEvent
      @isPropagationStopped = bb
      a and (a.stopPropagation and a.stopPropagation()
      a.cancelBubble = not 0
      )

      return

    stopImmediatePropagation: ->
      @isImmediatePropagationStopped = bb
      @stopPropagation()

      return

  n.each(
    mouseenter: "mouseover"
    mouseleave: "mouseout"
  , (a, b) ->
    n.event.special[a] =
      delegateType: b
      bindType: b
      handle: (a) ->
        c = undefined
        d = this
        e = a.relatedTarget
        f = a.handleObj
        (not e or e isnt d and not n.contains(d, e)) and (a.type = f.origType
        c = f.handler.apply(this, arguments_)
        a.type = b
        )
        c

    return
  )
  l.submitBubbles or (n.event.special.submit =
    setup: ->
      (if n.nodeName(this, "form") then not 1 else undefined)

    postDispatch: (a) ->
      a._submit_bubble and (delete a._submit_bubble

      @parentNode and not a.isTrigger and n.event.simulate("submit", @parentNode, a, not 0)
      )
      return

    teardown: ->
      (if n.nodeName(this, "form") then not 1 else undefined)
  )
  l.changeBubbles or (n.event.special.change =
    setup: ->
      (if Y.test(@nodeName) then (("checkbox" is @type or "radio" is @type) and (n.event.add(this, "propertychange._change", (a) ->
        "checked" is a.originalEvent.propertyName and (@_just_changed = not 0)
        return
      )
      n.event.add(this, "click._change", (a) ->
        @_just_changed and not a.isTrigger and (@_just_changed = not 1)
        n.event.simulate("change", this, a, not 0)

        return
      )
      )
      not 1
      ) else undefined)

    handle: (a) ->
      b = a.target
      (if this isnt b or a.isSimulated or a.isTrigger or "radio" isnt b.type and "checkbox" isnt b.type then a.handleObj.handler.apply(this, arguments_) else undefined)

    teardown: ->
      n.event.remove(this, "._change")
      not Y.test(@nodeName)
  )
  l.focusinBubbles or n.each(
    focus: "focusin"
    blur: "focusout"
  , (a, b) ->
    c = (a) ->
      n.event.simulate b, a.target, n.event.fix(a), not 0
      return

    n.event.special[b] =
      setup: ->
        d = @ownerDocument or this
        e = n._data(d, b)
        e or d.addEventListener(a, c, not 0)
        n._data(d, b, (e or 0) + 1)

        return

      teardown: ->
        d = @ownerDocument or this
        e = n._data(d, b) - 1
        (if e then n._data(d, b, e) else (d.removeEventListener(a, c, not 0)
        n._removeData(d, b)
        ))
        return

    return
  )
  n.fn.extend(
    on: (a, b, c, d, e) ->
      f = undefined
      g = undefined
      if "object" is typeof a
        "string" isnt typeof b and (c = c or b
        b = undefined
        )
        for f of a
          continue
        return this
      if (if null is c and null is d then (d = b
      c = b = undefined
      ) else null is d and ((if "string" is typeof b then (d = c
      c = undefined
      ) else (d = c
      c = b
      b = undefined
      ))))
      d is not 1
        d = cb
      else return this  unless d
      1 is e and (g = d
      d = (a) ->
        n().off(a)
        g.apply(this, arguments_)

      d.guid = g.guid or (g.guid = n.guid++)
      )
      @each(->
        n.event.add this, a, d, c, b
        return
      )

    one: (a, b, c, d) ->
      @on a, b, c, d, 1

    off: (a, b, c) ->
      d = undefined
      e = undefined
      if a and a.preventDefault and a.handleObj
        return d = a.handleObj
        n(a.delegateTarget).off((if d.namespace then d.origType + "." + d.namespace else d.origType), d.selector, d.handler)
        this
      if "object" is typeof a
        for e of a
          continue
        return this
      (b is not 1 or "function" is typeof b) and (c = b
      b = undefined
      )
      c is not 1 and (c = cb)
      @each(->
        n.event.remove this, a, c, b
        return
      )

    trigger: (a, b) ->
      @each ->
        n.event.trigger a, b, this
        return


    triggerHandler: (a, b) ->
      c = this[0]
      (if c then n.event.trigger(a, b, c, not 0) else undefined)
  )

  fb = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video"
  gb = RegExp(" jQuery\\d+=\"(?:null|\\d+)\"", "g")
  hb = new RegExp("<(?:" + fb + ")[\\s/>]", "i")
  ib = /^\s+/
  jb = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/g
  kb = /<([\w:]+)/
  lb = /<tbody/i
  mb = /<|&#?\w+;/
  nb = /<(?:script|style|link)/i
  ob = /checked\s*(?:[^=]|=\s*.checked.)/i
  pb = /^$|\/(?:java|ecma)script/i
  qb = /^true\/(.*)/
  rb = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g
  sb =
    option: [
      1
      "<select multiple='multiple'>"
      "</select>"
    ]
    legend: [
      1
      "<fieldset>"
      "</fieldset>"
    ]
    area: [
      1
      "<map>"
      "</map>"
    ]
    param: [
      1
      "<object>"
      "</object>"
    ]
    thead: [
      1
      "<table>"
      "</table>"
    ]
    tr: [
      2
      "<table><tbody>"
      "</tbody></table>"
    ]
    col: [
      2
      "<table><tbody></tbody><colgroup>"
      "</colgroup></table>"
    ]
    td: [
      3
      "<table><tbody><tr>"
      "</tr></tbody></table>"
    ]
    _default: (if l.htmlSerialize then [
      0
      ""
      ""
    ] else [
      1
      "X<div>"
      "</div>"
    ])

  tb = eb(z)
  ub = tb.appendChild(z.createElement("div"))
  sb.optgroup = sb.option
  sb.tbody = sb.tfoot = sb.colgroup = sb.caption = sb.thead
  sb.th = sb.td

  n.extend(
    clone: (a, b, c) ->
      d = undefined
      e = undefined
      f = undefined
      g = undefined
      h = undefined
      i = n.contains(a.ownerDocument, a)
      if (if l.html5Clone or n.isXMLDoc(a) or not hb.test("<" + a.nodeName + ">") then f = a.cloneNode(not 0) else (ub.innerHTML = a.outerHTML
      ub.removeChild(f = ub.firstChild)
      ))
      not (l.noCloneEvent and l.noCloneChecked or 1 isnt a.nodeType and 11 isnt a.nodeType or n.isXMLDoc(a))
        d = vb(f)
        h = vb(a)
        g = 0

        while null isnt (e = h[g])
          d[g] and Cb(e, d[g])
          ++g
      if b
        if c
          h = h or vb(a)
          d = d or vb(f)
          g = 0

          while null isnt (e = h[g])
            Bb e, d[g]
            g++
        else
          Bb a, f
      d = vb(f, "script")
      d.length > 0 and Ab(d, not i and vb(a, "script"))
      d = h = e = null
      f

    buildFragment: (a, b, c, d) ->
      e = undefined
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      k = undefined
      m = a.length
      o = eb(b)
      p = []
      q = 0

      while m > q
        if f = a[q]
        f or 0 is f
          if "object" is n.type(f)
            n.merge p, (if f.nodeType then [f] else f)
          else if mb.test(f)
            h = h or o.appendChild(b.createElement("div"))
            i = (kb.exec(f) or [
              ""
              ""
            ])[1].toLowerCase()
            k = sb[i] or sb._default
            h.innerHTML = k[1] + f.replace(jb, "<$1></$2>") + k[2]
            e = k[0]

            h = h.lastChild  while e--
            if not l.leadingWhitespace and ib.test(f) and p.push(b.createTextNode(ib.exec(f)[0]))
            not l.tbody
              f = (if "table" isnt i or lb.test(f) then (if "<table>" isnt k[1] or lb.test(f) then 0 else h) else h.firstChild)
              e = f and f.childNodes.length

              n.nodeName(j = f.childNodes[e], "tbody") and not j.childNodes.length and f.removeChild(j)  while e--
            n.merge(p, h.childNodes)
            h.textContent = ""

            h.removeChild h.firstChild  while h.firstChild
            h = o.lastChild
          else
            p.push b.createTextNode(f)
        q++
      h and o.removeChild(h)
      l.appendChecked or n.grep(vb(p, "input"), wb)
      q = 0

      while f = p[q++]
        if (not d or -1 is n.inArray(f, d)) and (g = n.contains(f.ownerDocument, f)
        h = vb(o.appendChild(f), "script")
        g and Ab(h)
        c
        )
          e = 0
          pb.test(f.type or "") and c.push(f)  while f = h[e++]
      h = null
      o

    cleanData: (a, b) ->
      d = undefined
      e = undefined
      f = undefined
      g = undefined
      h = 0
      i = n.expando
      j = n.cache
      k = l.deleteExpando
      m = n.event.special

      while null isnt (d = a[h])
        if (b or n.acceptData(d)) and (f = d[i]
        g = f and j[f]
        )
          if g.events
            for e of g.events
              continue
          j[f] and (delete j[f]

          (if k then delete d[i]
           else (if typeof d.removeAttribute isnt L then d.removeAttribute(i) else d[i] = null))
          c.push(f)
          )
        h++
      return
  )
  n.fn.extend(
    text: (a) ->
      W this, ((a) ->
        (if undefined is a then n.text(this) else @empty().append((this[0] and this[0].ownerDocument or z).createTextNode(a)))
      ), null, a, arguments_.length

    append: ->
      @domManip arguments_, (a) ->
        if 1 is @nodeType or 11 is @nodeType or 9 is @nodeType
          b = xb(this, a)
          b.appendChild a
        return


    prepend: ->
      @domManip arguments_, (a) ->
        if 1 is @nodeType or 11 is @nodeType or 9 is @nodeType
          b = xb(this, a)
          b.insertBefore a, b.firstChild
        return


    before: ->
      @domManip arguments_, (a) ->
        @parentNode and @parentNode.insertBefore(a, this)
        return


    after: ->
      @domManip arguments_, (a) ->
        @parentNode and @parentNode.insertBefore(a, @nextSibling)
        return


    remove: (a, b) ->
      c = undefined
      d = (if a then n.filter(a, this) else this)
      e = 0

      while null isnt (c = d[e])
        b or 1 isnt c.nodeType or n.cleanData(vb(c))
        c.parentNode and (b and n.contains(c.ownerDocument, c) and Ab(vb(c, "script"))
        c.parentNode.removeChild(c)
        )
        e++
      this

    empty: ->
      a = undefined
      b = 0

      while null isnt (a = this[b])
        1 is a.nodeType and n.cleanData(vb(a, not 1))
        a.removeChild a.firstChild  while a.firstChild
        a.options and n.nodeName(a, "select") and (a.options.length = 0)
        b++
      this

    clone: (a, b) ->
      a = (if null is a then not 1 else a)
      b = (if null is b then a else b)
      @map(->
        n.clone this, a, b
      )

    html: (a) ->
      W this, ((a) ->
        b = this[0] or {}
        c = 0
        d = @length
        return (if 1 is b.nodeType then b.innerHTML.replace(gb, "") else undefined)  if undefined is a
        unless "string" isnt typeof a or nb.test(a) or not l.htmlSerialize and hb.test(a) or not l.leadingWhitespace and ib.test(a) or sb[(kb.exec(a) or [
          ""
          ""
        ])[1].toLowerCase()]
          a = a.replace(jb, "<$1></$2>")
          try
            while d > c
              b = this[c] or {}
              1 is b.nodeType and (n.cleanData(vb(b, not 1))
              b.innerHTML = a
              )
              c++
            b = 0
        b and @empty().append(a)
        return
      ), null, a, arguments_.length

    replaceWith: ->
      a = arguments_[0]
      @domManip(arguments_, (b) ->
        a = @parentNode
        n.cleanData(vb(this))
        a and a.replaceChild(b, this)

        return
      )
      (if a and (a.length or a.nodeType) then this else @remove())

    detach: (a) ->
      @remove a, not 0

    domManip: (a, b) ->
      a = e.apply([], a)
      c = undefined
      d = undefined
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = 0
      k = @length
      m = this
      o = k - 1
      p = a[0]
      q = n.isFunction(p)
      if q or k > 1 and "string" is typeof p and not l.checkClone and ob.test(p)
        return @each((c) ->
          d = m.eq(c)
          q and (a[0] = p.call(this, c, d.html()))
          d.domManip(a, b)

          return
        )
      if k and (i = n.buildFragment(a, this[0].ownerDocument, not 1, this)
      c = i.firstChild
      1 is i.childNodes.length and (i = c)
      c
      )
        g = n.map(vb(i, "script"), yb)
        f = g.length

        while k > j
          d = i
          j isnt o and (d = n.clone(d, not 0, not 0)
          f and n.merge(g, vb(d, "script"))
          )
          b.call(this[j], d, j)
          j++
        if f
          h = g[g.length - 1].ownerDocument
          n.map(g, zb)
          j = 0

          while f > j
            d = g[j]
            pb.test(d.type or "") and not n._data(d, "globalEval") and n.contains(h, d) and ((if d.src then n._evalUrl and n._evalUrl(d.src) else n.globalEval((d.text or d.textContent or d.innerHTML or "").replace(rb, ""))))
            j++
        i = c = null
      this
  )
  n.each(
    appendTo: "append"
    prependTo: "prepend"
    insertBefore: "before"
    insertAfter: "after"
    replaceAll: "replaceWith"
  , (a, b) ->
    n.fn[a] = (a) ->
      c = undefined
      d = 0
      e = []
      g = n(a)
      h = g.length - 1

      while h >= d
        c = (if d is h then this else @clone(not 0))
        n(g[d])[b](c)
        f.apply(e, c.get())
        d++
      @pushStack e

    return
  )

  Db = undefined
  Eb = {}
  not ->
    a = undefined
    b = undefined
    c = z.createElement("div")
    d = "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0"
    c.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
    a = c.getElementsByTagName("a")[0]
    a.style.cssText = "float:left;opacity:.5"
    l.opacity = /^0.5/.test(a.style.opacity)
    l.cssFloat = !!a.style.cssFloat
    c.style.backgroundClip = "content-box"
    c.cloneNode(not 0).style.backgroundClip = ""
    l.clearCloneStyle = "content-box" is c.style.backgroundClip
    a = c = null
    l.shrinkWrapBlocks = ->
      a = undefined
      c = undefined
      e = undefined
      f = undefined
      if null is b
        return  if a = z.getElementsByTagName("body")[0]
        not a

        f = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px"
        c = z.createElement("div")
        e = z.createElement("div")
        a.appendChild(c).appendChild(e)
        b = not 1
        typeof e.style.zoom isnt L and (e.style.cssText = d + ";width:1px;padding:1px;zoom:1"
        e.innerHTML = "<div></div>"
        e.firstChild.style.width = "5px"
        b = 3 isnt e.offsetWidth
        )
        a.removeChild(c)
        a = c = e = null
      b


    return
  ()
  Hb = /^margin/
  Ib = new RegExp("^(" + T + ")(?!px)[a-z%]+$", "i")
  Jb = undefined
  Kb = undefined
  Lb = /^(top|right|bottom|left)$/
  (if a.getComputedStyle then (Jb = (a) ->
    a.ownerDocument.defaultView.getComputedStyle a, null

  Kb = (a, b, c) ->
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = a.style
    c = c or Jb(a)
    g = (if c then c.getPropertyValue(b) or c[b] else undefined)
    c and ("" isnt g or n.contains(a.ownerDocument, a) or (g = n.style(a, b))
    Ib.test(g) and Hb.test(b) and (d = h.width
    e = h.minWidth
    f = h.maxWidth
    h.minWidth = h.maxWidth = h.width = g
    g = c.width
    h.width = d
    h.minWidth = e
    h.maxWidth = f
    )
    )
    (if undefined is g then g else g + "")

  ) else z.documentElement.currentStyle and (Jb = (a) ->
    a.currentStyle

  Kb = (a, b, c) ->
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = a.style
    c = c or Jb(a)
    g = (if c then c[b] else undefined)
    null is g and h and h[b] and (g = h[b])
    Ib.test(g) and not Lb.test(b) and (d = h.left
    e = a.runtimeStyle
    f = e and e.left
    f and (e.left = a.currentStyle.left)
    h.left = (if "fontSize" is b then "1em" else g)
    g = h.pixelLeft + "px"
    h.left = d
    f and (e.left = f)
    )
    (if undefined is g then g else g + "" or "auto")

  ))
  not ->
    k = ->
      b = undefined
      c = undefined
      h = z.getElementsByTagName("body")[0]
      h and (b = z.createElement("div")
      c = z.createElement("div")
      b.style.cssText = i
      h.appendChild(b).appendChild(c)
      c.style.cssText = "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;position:absolute;display:block;padding:1px;border:1px;width:4px;margin-top:1%;top:1%"
      n.swap(h, (if null isnt h.style.zoom then zoom: 1 else {}), ->
        d = 4 is c.offsetWidth
        return
      )
      e = not 0
      f = not 1
      g = not 0
      a.getComputedStyle and (f = "1%" isnt (a.getComputedStyle(c, null) or {}).top
      e = "4px" is (a.getComputedStyle(c, null) or width: "4px").width
      )
      h.removeChild(b)
      c = h = null
      )
      return
    b = undefined
    c = undefined
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = z.createElement("div")
    i = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px"
    j = "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0"
    h.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
    b = h.getElementsByTagName("a")[0]
    b.style.cssText = "float:left;opacity:.5"
    l.opacity = /^0.5/.test(b.style.opacity)
    l.cssFloat = !!b.style.cssFloat
    h.style.backgroundClip = "content-box"
    h.cloneNode(not 0).style.backgroundClip = ""
    l.clearCloneStyle = "content-box" is h.style.backgroundClip
    b = h = null
    n.extend(l,
      reliableHiddenOffsets: ->
        return c  unless null is c
        a = undefined
        b = undefined
        d = undefined
        e = z.createElement("div")
        f = z.getElementsByTagName("body")[0]
        if f
          e.setAttribute("className", "t")
          e.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
          a = z.createElement("div")
          a.style.cssText = i
          f.appendChild(a).appendChild(e)
          e.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"
          b = e.getElementsByTagName("td")
          b[0].style.cssText = "padding:0;margin:0;border:0;display:none"
          d = 0 is b[0].offsetHeight
          b[0].style.display = ""
          b[1].style.display = "none"
          c = d and 0 is b[0].offsetHeight
          f.removeChild(a)
          e = f = null
          c

      boxSizing: ->
        null is d and k()
        d

      boxSizingReliable: ->
        null is e and k()
        e

      pixelPosition: ->
        null is f and k()
        f

      reliableMarginRight: ->
        b = undefined
        c = undefined
        d = undefined
        e = undefined
        if null is g and a.getComputedStyle
          return  if b = z.getElementsByTagName("body")[0]
          not b

          c = z.createElement("div")
          d = z.createElement("div")
          c.style.cssText = i
          b.appendChild(c).appendChild(d)
          e = d.appendChild(z.createElement("div"))
          e.style.cssText = d.style.cssText = j
          e.style.marginRight = e.style.width = "0"
          d.style.width = "1px"
          g = not parseFloat((a.getComputedStyle(e, null) or {}).marginRight)
          b.removeChild(c)
        g
    )

    return
  ()
  n.swap = (a, b, c, d) ->
    e = undefined
    f = undefined
    g = {}
    for f of b
      continue
    e = c.apply(a, d or [])
    for f of b
      continue
    e


  Nb = /alpha\([^)]*\)/i
  Ob = /opacity\s*=\s*([^)]*)/
  Pb = /^(none|table(?!-c[ea]).+)/
  Qb = new RegExp("^(" + T + ")(.*)$", "i")
  Rb = new RegExp("^([+-])=(" + T + ")", "i")
  Sb =
    position: "absolute"
    visibility: "hidden"
    display: "block"

  Tb =
    letterSpacing: 0
    fontWeight: 400

  Ub = [
    "Webkit"
    "O"
    "Moz"
    "ms"
  ]
  n.extend(
    cssHooks:
      opacity:
        get: (a, b) ->
          if b
            c = Kb(a, "opacity")
            (if "" is c then "1" else c)

    cssNumber:
      columnCount: not 0
      fillOpacity: not 0
      fontWeight: not 0
      lineHeight: not 0
      opacity: not 0
      order: not 0
      orphans: not 0
      widows: not 0
      zIndex: not 0
      zoom: not 0

    cssProps:
      float: (if l.cssFloat then "cssFloat" else "styleFloat")

    style: (a, b, c, d) ->
      if a and 3 isnt a.nodeType and 8 isnt a.nodeType and a.style
        e = undefined
        f = undefined
        g = undefined
        h = n.camelCase(b)
        i = a.style
        return (if g and "get" of g and undefined isnt (e = g.get(a, not 1, d)) then e else i[b])  if b = n.cssProps[h] or (n.cssProps[h] = Vb(i, h))
        g = n.cssHooks[b] or n.cssHooks[h]
        undefined is c

        if f = typeof c
        "string" is f and (e = Rb.exec(c)) and (c = (e[1] + 1) * e[2] + parseFloat(n.css(a, b))
        f = "number"
        )
        null isnt c and c is c and ("number" isnt f or n.cssNumber[h] or (c += "px")
        l.clearCloneStyle or "" isnt c or 0 isnt b.indexOf("background") or (i[b] = "inherit")
        not (g and "set" of g and undefined is (c = g.set(a, c, d)))
        )
          try
            i[b] = ""
            i[b] = c
      return

    css: (a, b, c, d) ->
      e = undefined
      f = undefined
      g = undefined
      h = n.camelCase(b)
      b = n.cssProps[h] or (n.cssProps[h] = Vb(a.style, h))
      g = n.cssHooks[b] or n.cssHooks[h]
      g and "get" of g and (f = g.get(a, not 0, c))
      undefined is f and (f = Kb(a, b, d))
      "normal" is f and b of Tb and (f = Tb[b])
      (if "" is c or c then (e = parseFloat(f)
      (if c is not 0 or n.isNumeric(e) then e or 0 else f)
      ) else f)
  )
  n.each([
    "height"
    "width"
  ], (a, b) ->
    n.cssHooks[b] =
      get: (a, c, d) ->
        (if c then (if 0 is a.offsetWidth and Pb.test(n.css(a, "display")) then n.swap(a, Sb, ->
          Zb a, b, d
        ) else Zb(a, b, d)) else undefined)

      set: (a, c, d) ->
        e = d and Jb(a)
        Xb a, c, (if d then Yb(a, b, d, l.boxSizing() and "border-box" is n.css(a, "boxSizing", not 1, e), e) else 0)

    return
  )
  l.opacity or (n.cssHooks.opacity =
    get: (a, b) ->
      (if Ob.test(((if b and a.currentStyle then a.currentStyle.filter else a.style.filter)) or "") then .01 * parseFloat(RegExp.$1) + "" else (if b then "1" else ""))

    set: (a, b) ->
      c = a.style
      d = a.currentStyle
      e = (if n.isNumeric(b) then "alpha(opacity=" + 100 * b + ")" else "")
      f = d and d.filter or c.filter or ""
      c.zoom = 1
      (b >= 1 or "" is b) and "" is n.trim(f.replace(Nb, "")) and c.removeAttribute and (c.removeAttribute("filter")
      "" is b or d and not d.filter
      ) or (c.filter = (if Nb.test(f) then f.replace(Nb, e) else f + " " + e))

      return
  )
  n.cssHooks.marginRight = Mb(l.reliableMarginRight, (a, b) ->
    (if b then n.swap(a,
      display: "inline-block"
    , Kb, [
      a
      "marginRight"
    ]) else undefined)
  )
  n.each(
    margin: ""
    padding: ""
    border: "Width"
  , (a, b) ->
    n.cssHooks[a + b] = expand: (c) ->
      d = 0
      e = {}
      f = (if "string" is typeof c then c.split(" ") else [c])

      while 4 > d
        e[a + U[d] + b] = f[d] or f[d - 2] or f[0]
        d++
      e

    Hb.test(a) or (n.cssHooks[a + b].set = Xb)

    return
  )
  n.fn.extend(
    css: (a, b) ->
      W this, ((a, b, c) ->
        d = undefined
        e = undefined
        f = {}
        g = 0
        if n.isArray(b)
          d = Jb(a)
          e = b.length

          while e > g
            f[b[g]] = n.css(a, b[g], not 1, d)
            g++
          return f
        (if undefined isnt c then n.style(a, b, c) else n.css(a, b))
      ), a, b, arguments_.length > 1

    show: ->
      Wb this, not 0

    hide: ->
      Wb this

    toggle: (a) ->
      (if "boolean" is typeof a then (if a then @show() else @hide()) else @each(->
        (if V(this) then n(this).show() else n(this).hide())
        return
      ))
  )

  n.Tween = $b
  $b:: =
    constructor: $b
    init: (a, b, c, d, e, f) ->
      @elem = a
      @prop = c
      @easing = e or "swing"
      @options = b
      @start = @now = @cur()
      @end = d
      @unit = f or ((if n.cssNumber[c] then "" else "px"))

      return

    cur: ->
      a = $b.propHooks[@prop]
      (if a and a.get then a.get(this) else $b.propHooks._default.get(this))

    run: (a) ->
      b = undefined
      c = $b.propHooks[@prop]
      @pos = b = (if @options.duration then n.easing[@easing](a, @options.duration * a, 0, 1, @options.duration) else a)
      @now = (@end - @start) * b + @start
      @options.step and @options.step.call(@elem, @now, this)
      (if c and c.set then c.set(this) else $b.propHooks._default.set(this))
      this

  $b::init:: = $b::
  $b.propHooks = _default:
    get: (a) ->
      b = undefined
      (if null is a.elem[a.prop] or a.elem.style and null isnt a.elem.style[a.prop] then (b = n.css(a.elem, a.prop, "")
      (if b and "auto" isnt b then b else 0)
      ) else a.elem[a.prop])

    set: (a) ->
      (if n.fx.step[a.prop] then n.fx.step[a.prop](a) else (if a.elem.style and (null isnt a.elem.style[n.cssProps[a.prop]] or n.cssHooks[a.prop]) then n.style(a.elem, a.prop, a.now + a.unit) else a.elem[a.prop] = a.now))
      return

  $b.propHooks.scrollTop = $b.propHooks.scrollLeft = set: (a) ->
    a.elem.nodeType and a.elem.parentNode and (a.elem[a.prop] = a.now)
    return

  n.easing =
    linear: (a) ->
      a

    swing: (a) ->
      .5 - Math.cos(a * Math.PI) / 2

  n.fx = $b::init
  n.fx.step = {}

  _b = undefined
  ac = undefined
  bc = /^(?:toggle|show|hide)$/
  cc = new RegExp("^(?:([+-])=|)(" + T + ")([a-z%]*)$", "i")
  dc = /queueHooks$/
  ec = [jc]
  fc = "*": [(a, b) ->
    c = @createTween(a, b)
    d = c.cur()
    e = cc.exec(b)
    f = e and e[3] or ((if n.cssNumber[a] then "" else "px"))
    g = (n.cssNumber[a] or "px" isnt f and +d) and cc.exec(n.css(c.elem, a))
    h = 1
    i = 20
    if g and g[3] isnt f
      f = f or g[3]
      e = e or []
      g = +d or 1

      loop
        h = h or ".5"
        g /= h
        n.style(c.elem, a, g + f)
        break unless h isnt (h = c.cur() / d) and 1 isnt h and --i
    e and (g = c.start = +g or +d or 0
    c.unit = f
    c.end = (if e[1] then g + (e[1] + 1) * e[2] else +e[2])
    )
    c
  ]
  n.Animation = n.extend(lc,
    tweener: (a, b) ->
      (if n.isFunction(a) then (b = a
      a = ["*"]
      ) else a = a.split(" "))
      c = undefined
      d = 0
      e = a.length

      while e > d
        c = a[d]
        fc[c] = fc[c] or []
        fc[c].unshift(b)
        d++
      return

    prefilter: (a, b) ->
      (if b then ec.unshift(a) else ec.push(a))
      return
  )
  n.speed = (a, b, c) ->
    d = (if a and "object" is typeof a then n.extend({}, a) else
      complete: c or not c and b or n.isFunction(a) and a
      duration: a
      easing: c and b or b and not n.isFunction(b) and b
    )
    d.duration = (if n.fx.off then 0 else (if "number" is typeof d.duration then d.duration else (if d.duration of n.fx.speeds then n.fx.speeds[d.duration] else n.fx.speeds._default)))
    (null is d.queue or d.queue is not 0) and (d.queue = "fx")
    d.old = d.complete
    d.complete = ->
      n.isFunction(d.old) and d.old.call(this)
      d.queue and n.dequeue(this, d.queue)

      return

    d

  n.fn.extend(
    fadeTo: (a, b, c, d) ->
      @filter(V).css("opacity", 0).show().end().animate
        opacity: b
      , a, c, d

    animate: (a, b, c, d) ->
      e = n.isEmptyObject(a)
      f = n.speed(b, c, d)
      g = ->
        b = lc(this, n.extend({}, a), f)
        (e or n._data(this, "finish")) and b.stop(not 0)
        return

      g.finish = g
      (if e or f.queue is not 1 then @each(g) else @queue(f.queue, g))

    stop: (a, b, c) ->
      d = (a) ->
        b = a.stop
        delete a.stop

        b(c)

        return

      "string" isnt typeof a and (c = b
      b = a
      a = undefined
      )
      b and a isnt not 1 and @queue(a or "fx", [])
      @each(->
        b = not 0
        e = null isnt a and a + "queueHooks"
        f = n.timers
        g = n._data(this)
        if e
          g[e] and g[e].stop and d(g[e])
        else
          for e of g
            continue
        e = f.length
        while e--
          f[e].elem isnt this or null isnt a and f[e].queue isnt a or (f[e].anim.stop(c)
          b = not 1
          f.splice(e, 1)
          )
        (b or not c) and n.dequeue(this, a)
        return
      )

    finish: (a) ->
      a isnt not 1 and (a = a or "fx")
      @each(->
        b = undefined
        c = n._data(this)
        d = c[a + "queue"]
        e = c[a + "queueHooks"]
        f = n.timers
        g = (if d then d.length else 0)
        c.finish = not 0
        n.queue(this, a, [])
        e and e.stop and e.stop.call(this, not 0)
        b = f.length

        while b--
          f[b].elem is this and f[b].queue is a and (f[b].anim.stop(not 0)
          f.splice(b, 1)
          )
        b = 0
        while g > b
          d[b] and d[b].finish and d[b].finish.call(this)
          b++
        delete c.finish

        return
      )
  )
  n.each([
    "toggle"
    "show"
    "hide"
  ], (a, b) ->
    c = n.fn[b]
    n.fn[b] = (a, d, e) ->
      (if null is a or "boolean" is typeof a then c.apply(this, arguments_) else @animate(hc(b, not 0), a, d, e))

    return
  )
  n.each(
    slideDown: hc("show")
    slideUp: hc("hide")
    slideToggle: hc("toggle")
    fadeIn:
      opacity: "show"

    fadeOut:
      opacity: "hide"

    fadeToggle:
      opacity: "toggle"
  , (a, b) ->
    n.fn[a] = (a, c, d) ->
      @animate b, a, c, d

    return
  )
  n.timers = []
  n.fx.tick = ->
    a = undefined
    b = n.timers
    c = 0
    _b = n.now()
    while c < b.length
      a = b[c]
      a() or b[c] isnt a or b.splice(c--, 1)
      c++
    b.length or n.fx.stop()
    _b = undefined

    return

  n.fx.timer = (a) ->
    n.timers.push(a)
    (if a() then n.fx.start() else n.timers.pop())

    return

  n.fx.interval = 13
  n.fx.start = ->
    ac or (ac = setInterval(n.fx.tick, n.fx.interval))
    return

  n.fx.stop = ->
    clearInterval(ac)
    ac = null

    return

  n.fx.speeds =
    slow: 600
    fast: 200
    _default: 400

  n.fn.delay = (a, b) ->
    a = (if n.fx then n.fx.speeds[a] or a else a)
    b = b or "fx"
    @queue(b, (b, c) ->
      d = setTimeout(b, a)
      c.stop = ->
        clearTimeout d
        return

      return
    )

  ->
    a = undefined
    b = undefined
    c = undefined
    d = undefined
    e = z.createElement("div")
    e.setAttribute("className", "t")
    e.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"
    a = e.getElementsByTagName("a")[0]
    c = z.createElement("select")
    d = c.appendChild(z.createElement("option"))
    b = e.getElementsByTagName("input")[0]
    a.style.cssText = "top:1px"
    l.getSetAttribute = "t" isnt e.className
    l.style = /top/.test(a.getAttribute("style"))
    l.hrefNormalized = "/a" is a.getAttribute("href")
    l.checkOn = !!b.value
    l.optSelected = d.selected
    l.enctype = !!z.createElement("form").enctype
    c.disabled = not 0
    l.optDisabled = not d.disabled
    b = z.createElement("input")
    b.setAttribute("value", "")
    l.input = "" is b.getAttribute("value")
    b.value = "t"
    b.setAttribute("type", "radio")
    l.radioValue = "t" is b.value
    a = b = c = d = e = null

    return
  ()

  mc = /\r/g
  n.fn.extend(val: (a) ->
    b = undefined
    c = undefined
    d = undefined
    e = this[0]
    if arguments_.length
      return d = n.isFunction(a)
      @each((c) ->
        e = undefined
        1 is @nodeType and (e = (if d then a.call(this, c, n(this).val()) else a)
        (if null is e then e = "" else (if "number" is typeof e then e += "" else n.isArray(e) and (e = n.map(e, (a) ->
          (if null is a then "" else a + "")
        ))))
        b = n.valHooks[@type] or n.valHooks[@nodeName.toLowerCase()]
        b and "set" of b and undefined isnt b.set(this, e, "value") or (@value = e)
        )
        return
      )
    if e
      b = n.valHooks[e.type] or n.valHooks[e.nodeName.toLowerCase()]
      (if b and "get" of b and undefined isnt (c = b.get(e, "value")) then c else (c = e.value
      (if "string" is typeof c then c.replace(mc, "") else (if null is c then "" else c))
      ))
  )
  n.extend(valHooks:
    option:
      get: (a) ->
        b = n.find.attr(a, "value")
        (if null isnt b then b else n.text(a))

    select:
      get: (a) ->
        b = undefined
        c = undefined
        d = a.options
        e = a.selectedIndex
        f = "select-one" is a.type or 0 > e
        g = (if f then null else [])
        h = (if f then e + 1 else d.length)
        i = (if 0 > e then h else (if f then e else 0))

        while h > i
          if c = d[i]
          not (not c.selected and i isnt e or ((if l.optDisabled then c.disabled else null isnt c.getAttribute("disabled"))) or c.parentNode.disabled and n.nodeName(c.parentNode, "optgroup"))
            return b  if b = n(c).val()
            f

            g.push b
          i++
        g

      set: (a, b) ->
        c = undefined
        d = undefined
        e = a.options
        f = n.makeArray(b)
        g = e.length
        while g--
          if d = e[g]
          n.inArray(n.valHooks.option.get(d), f) >= 0
            try
              d.selected = c = not 0
            catch h
              d.scrollHeight
          else
            d.selected = not 1
        c or (a.selectedIndex = -1)
        e
  )
  n.each([
    "radio"
    "checkbox"
  ], ->
    n.valHooks[this] = set: (a, b) ->
      (if n.isArray(b) then a.checked = n.inArray(n(a).val(), b) >= 0 else undefined)

    l.checkOn or (n.valHooks[this].get = (a) ->
      (if null is a.getAttribute("value") then "on" else a.value)
    )

    return
  )

  nc = undefined
  oc = undefined
  pc = n.expr.attrHandle
  qc = /^(?:checked|selected)$/i
  rc = l.getSetAttribute
  sc = l.input
  n.fn.extend(
    attr: (a, b) ->
      W this, n.attr, a, b, arguments_.length > 1

    removeAttr: (a) ->
      @each ->
        n.removeAttr this, a
        return

  )
  n.extend(
    attr: (a, b, c) ->
      d = undefined
      e = undefined
      f = a.nodeType
      if a and 3 isnt f and 8 isnt f and 2 isnt f
        (if typeof a.getAttribute is L then n.prop(a, b, c) else (1 is f and n.isXMLDoc(a) or (b = b.toLowerCase()
        d = n.attrHooks[b] or ((if n.expr.match.bool.test(b) then oc else nc))
        )
        (if undefined is c then (if d and "get" of d and null isnt (e = d.get(a, b)) then e else (e = n.find.attr(a, b)
        (if null is e then undefined else e)
        )) else (if null isnt c then (if d and "set" of d and undefined isnt (e = d.set(a, c, b)) then e else (a.setAttribute(b, c + "")
        c
        )) else undefined))
        ))

    removeAttr: (a, b) ->
      c = undefined
      d = undefined
      e = 0
      f = b and b.match(F)
      if f and 1 is a.nodeType
        while c = f[e++]
          d = n.propFix[c] or c
          (if n.expr.match.bool.test(c) then (if sc and rc or not qc.test(c) then a[d] = not 1 else a[n.camelCase("default-" + c)] = a[d] = not 1) else n.attr(a, c, ""))
          a.removeAttribute((if rc then c else d))
      return

    attrHooks:
      type:
        set: (a, b) ->
          if not l.radioValue and "radio" is b and n.nodeName(a, "input")
            c = a.value
            a.setAttribute("type", b)
            c and (a.value = c)
            b
  )
  oc = set: (a, b, c) ->
    (if b is not 1 then n.removeAttr(a, c) else (if sc and rc or not qc.test(c) then a.setAttribute(not rc and n.propFix[c] or c, c) else a[n.camelCase("default-" + c)] = a[c] = not 0))
    c

  n.each(n.expr.match.bool.source.match(/\w+/g), (a, b) ->
    c = pc[b] or n.find.attr
    pc[b] = (if sc and rc or not qc.test(b) then (a, b, d) ->
      e = undefined
      f = undefined
      d or (f = pc[b]
      pc[b] = e
      e = (if null isnt c(a, b, d) then b.toLowerCase() else null)
      pc[b] = f
      )
      e
     else (a, b, c) ->
      (if c then undefined else (if a[n.camelCase("default-" + b)] then b.toLowerCase() else null))
    )
    return
  )
  sc and rc or (n.attrHooks.value = set: (a, b, c) ->
    (if n.nodeName(a, "input") then undefined else nc and nc.set(a, b, c))
  )
  rc or (nc = set: (a, b, c) ->
    d = a.getAttributeNode(c)
    d or a.setAttributeNode(d = a.ownerDocument.createAttribute(c))
    d.value = b += ""
    (if "value" is c or b is a.getAttribute(c) then b else undefined)

  pc.id = pc.name = pc.coords = (a, b, c) ->
    d = undefined
    (if c then undefined else (if (d = a.getAttributeNode(b)) and "" isnt d.value then d.value else null))

  n.valHooks.button =
    get: (a, b) ->
      c = a.getAttributeNode(b)
      (if c and c.specified then c.value else undefined)

    set: nc.set

  n.attrHooks.contenteditable = set: (a, b, c) ->
    nc.set a, (if "" is b then not 1 else b), c
    return

  n.each([
    "width"
    "height"
  ], (a, b) ->
    n.attrHooks[b] = set: (a, c) ->
      (if "" is c then (a.setAttribute(b, "auto")
      c
      ) else undefined)

    return
  )
  )
  l.style or (n.attrHooks.style =
    get: (a) ->
      a.style.cssText or undefined

    set: (a, b) ->
      a.style.cssText = b + ""
  )

  tc = /^(?:input|select|textarea|button|object)$/i
  uc = /^(?:a|area)$/i
  n.fn.extend(
    prop: (a, b) ->
      W this, n.prop, a, b, arguments_.length > 1

    removeProp: (a) ->
      a = n.propFix[a] or a
      @each(->
        try
          this[a] = undefined
          delete this[a]
        return
      )
  )
  n.extend(
    propFix:
      for: "htmlFor"
      class: "className"

    prop: (a, b, c) ->
      d = undefined
      e = undefined
      f = undefined
      g = a.nodeType
      if a and 3 isnt g and 8 isnt g and 2 isnt g
        f = 1 isnt g or not n.isXMLDoc(a)
        f and (b = n.propFix[b] or b
        e = n.propHooks[b]
        )
        (if undefined isnt c then (if e and "set" of e and undefined isnt (d = e.set(a, c, b)) then d else a[b] = c) else (if e and "get" of e and null isnt (d = e.get(a, b)) then d else a[b]))

    propHooks:
      tabIndex:
        get: (a) ->
          b = n.find.attr(a, "tabindex")
          (if b then parseInt(b, 10) else (if tc.test(a.nodeName) or uc.test(a.nodeName) and a.href then 0 else -1))
  )
  l.hrefNormalized or n.each([
    "href"
    "src"
  ], (a, b) ->
    n.propHooks[b] = get: (a) ->
      a.getAttribute b, 4

    return
  )
  l.optSelected or (n.propHooks.selected = get: (a) ->
    b = a.parentNode
    b and (b.selectedIndex
    b.parentNode and b.parentNode.selectedIndex
    )
    null
  )
  n.each([
    "tabIndex"
    "readOnly"
    "maxLength"
    "cellSpacing"
    "cellPadding"
    "rowSpan"
    "colSpan"
    "useMap"
    "frameBorder"
    "contentEditable"
  ], ->
    n.propFix[@toLowerCase()] = this
    return
  )
  l.enctype or (n.propFix.enctype = "encoding")

  vc = /[\t\r\n\f]/g
  n.fn.extend(
    addClass: (a) ->
      b = undefined
      c = undefined
      d = undefined
      e = undefined
      f = undefined
      g = undefined
      h = 0
      i = @length
      j = "string" is typeof a and a
      if n.isFunction(a)
        return @each((b) ->
          n(this).addClass a.call(this, b, @className)
          return
        )
      if j
        b = (a or "").match(F) or []
        while i > h
          if c = this[h]
          d = 1 is c.nodeType and ((if c.className then (" " + c.className + " ").replace(vc, " ") else " "))
            f = 0
            d.indexOf(" " + e + " ") < 0 and (d += e + " ")  while e = b[f++]
            g = n.trim(d)
            c.className isnt g and (c.className = g)
          h++
      this

    removeClass: (a) ->
      b = undefined
      c = undefined
      d = undefined
      e = undefined
      f = undefined
      g = undefined
      h = 0
      i = @length
      j = 0 is arguments_.length or "string" is typeof a and a
      if n.isFunction(a)
        return @each((b) ->
          n(this).removeClass a.call(this, b, @className)
          return
        )
      if j
        b = (a or "").match(F) or []
        while i > h
          if c = this[h]
          d = 1 is c.nodeType and ((if c.className then (" " + c.className + " ").replace(vc, " ") else ""))
            f = 0
            d = d.replace(" " + e + " ", " ")  while d.indexOf(" " + e + " ") >= 0  while e = b[f++]
            g = (if a then n.trim(d) else "")
            c.className isnt g and (c.className = g)
          h++
      this

    toggleClass: (a, b) ->
      c = typeof a
      (if "boolean" is typeof b and "string" is c then (if b then @addClass(a) else @removeClass(a)) else @each((if n.isFunction(a) then (c) ->
        n(this).toggleClass a.call(this, c, @className, b), b
        return
       else ->
        if "string" is c
          b = undefined
          d = 0
          e = n(this)
          f = a.match(F) or []
          (if e.hasClass(b) then e.removeClass(b) else e.addClass(b))  while b = f[d++]
        else
          (c is L or "boolean" is c) and (@className and n._data(this, "__className__", @className)
          @className = (if @className or a is not 1 then "" else n._data(this, "__className__") or "")
          )
        return
      )))

    hasClass: (a) ->
      b = " " + a + " "
      c = 0
      d = @length

      while d > c
        return not 0  if 1 is this[c].nodeType and (" " + this[c].className + " ").replace(vc, " ").indexOf(b) >= 0
        c++
      not 1
  )
  n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "), (a, b) ->
    n.fn[b] = (a, c) ->
      (if arguments_.length > 0 then @on(b, null, a, c) else @trigger(b))

    return
  )
  n.fn.extend(
    hover: (a, b) ->
      @mouseenter(a).mouseleave b or a

    bind: (a, b, c) ->
      @on a, null, b, c

    unbind: (a, b) ->
      @off a, null, b

    delegate: (a, b, c, d) ->
      @on b, a, c, d

    undelegate: (a, b, c) ->
      (if 1 is arguments_.length then @off(a, "**") else @off(b, a or "**", c))
  )

  wc = n.now()
  xc = /\?/
  yc = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g
  n.parseJSON = (b) ->
    return a.JSON.parse(b + "")  if a.JSON and a.JSON.parse
    c = undefined
    d = null
    e = n.trim(b + "")
    (if e and not n.trim(e.replace(yc, (a, b, e, f) ->
      c and b and (d = 0)
      (if 0 is d then a else (c = e or b
      d += not f - not e
      ""
      ))
    )) then Function("return " + e)() else n.error("Invalid JSON: " + b))

  n.parseXML = (b) ->
    c = undefined
    d = undefined
    return null  if not b or "string" isnt typeof b
    try
      (if a.DOMParser then (d = new DOMParser
      c = d.parseFromString(b, "text/xml")
      ) else (c = new ActiveXObject("Microsoft.XMLDOM")
      c.async = "false"
      c.loadXML(b)
      ))
    catch e
      c = undefined
    c and c.documentElement and not c.getElementsByTagName("parsererror").length or n.error("Invalid XML: " + b)
    c


  zc = undefined
  Ac = undefined
  Bc = /#.*$/
  Cc = /([?&])_=[^&]*/
  Dc = /^(.*?):[ \t]*([^\r\n]*)\r?$/g
  Ec = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/
  Fc = /^(?:GET|HEAD)$/
  Gc = /^\/\//
  Hc = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/
  Ic = {}
  Jc = {}
  Kc = "*/".concat("*")
  try
    Ac = location.href
  catch Lc
    Ac = z.createElement("a")
    Ac.href = ""
    Ac = Ac.href
  zc = Hc.exec(Ac.toLowerCase()) or []
  n.extend(
    active: 0
    lastModified: {}
    etag: {}
    ajaxSettings:
      url: Ac
      type: "GET"
      isLocal: Ec.test(zc[1])
      global: not 0
      processData: not 0
      async: not 0
      contentType: "application/x-www-form-urlencoded; charset=UTF-8"
      accepts:
        "*": Kc
        text: "text/plain"
        html: "text/html"
        xml: "application/xml, text/xml"
        json: "application/json, text/javascript"

      contents:
        xml: /xml/
        html: /html/
        json: /json/

      responseFields:
        xml: "responseXML"
        text: "responseText"
        json: "responseJSON"

      converters:
        "* text": String
        "text html": not 0
        "text json": n.parseJSON
        "text xml": n.parseXML

      flatOptions:
        url: not 0
        context: not 0

    ajaxSetup: (a, b) ->
      (if b then Oc(Oc(a, n.ajaxSettings), b) else Oc(n.ajaxSettings, a))

    ajaxPrefilter: Mc(Ic)
    ajaxTransport: Mc(Jc)
    ajax: (a, b) ->
      x = (a, b, c, d) ->
        j = undefined
        r = undefined
        s = undefined
        u = undefined
        w = undefined
        x = b
        2 isnt t and (t = 2
        g and clearTimeout(g)
        i = undefined
        f = d or ""
        v.readyState = (if a > 0 then 4 else 0)
        j = a >= 200 and 300 > a or 304 is a
        c and (u = Pc(k, v, c))
        u = Qc(k, u, v, j)
        (if j then (k.ifModified and (w = v.getResponseHeader("Last-Modified")
        w and (n.lastModified[e] = w)
        w = v.getResponseHeader("etag")
        w and (n.etag[e] = w)
        )
        (if 204 is a or "HEAD" is k.type then x = "nocontent" else (if 304 is a then x = "notmodified" else (x = u.state
        r = u.data
        s = u.error
        j = not s
        )))
        ) else (s = x
        (a or not x) and (x = "error"
        0 > a and (a = 0)
        )
        ))
        v.status = a
        v.statusText = (b or x) + ""
        (if j then o.resolveWith(l, [
          r
          x
          v
        ]) else o.rejectWith(l, [
          v
          x
          s
        ]))
        v.statusCode(q)
        q = undefined
        h and m.trigger((if j then "ajaxSuccess" else "ajaxError"), [
          v
          k
          (if j then r else s)
        ])
        p.fireWith(l, [
          v
          x
        ])
        h and (m.trigger("ajaxComplete", [
          v
          k
        ])
        --n.active or n.event.trigger("ajaxStop")
        )
        )
        return
      "object" is typeof a and (b = a
      a = undefined
      )
      b = b or {}

      c = undefined
      d = undefined
      e = undefined
      f = undefined
      g = undefined
      h = undefined
      i = undefined
      j = undefined
      k = n.ajaxSetup({}, b)
      l = k.context or k
      m = (if k.context and (l.nodeType or l.jquery) then n(l) else n.event)
      o = n.Deferred()
      p = n.Callbacks("once memory")
      q = k.statusCode or {}
      r = {}
      s = {}
      t = 0
      u = "canceled"
      v =
        readyState: 0
        getResponseHeader: (a) ->
          b = undefined
          if 2 is t
            unless j
              j = {}
              j[b[1].toLowerCase()] = b[2]  while b = Dc.exec(f)
            b = j[a.toLowerCase()]
          (if null is b then null else b)

        getAllResponseHeaders: ->
          (if 2 is t then f else null)

        setRequestHeader: (a, b) ->
          c = a.toLowerCase()
          t or (a = s[c] = s[c] or a
          r[a] = b
          )
          this

        overrideMimeType: (a) ->
          t or (k.mimeType = a)
          this

        statusCode: (a) ->
          b = undefined
          if a
            if 2 > t
              for b of a
                continue
            else
              v.always a[v.status]
          this

        abort: (a) ->
          b = a or u
          i and i.abort(b)
          x(0, b)
          this

      return v  if o.promise(v).complete = p.add
      v.success = v.done
      v.error = v.fail
      k.url = ((a or k.url or Ac) + "").replace(Bc, "").replace(Gc, zc[1] + "//")
      k.type = b.method or b.type or k.method or k.type
      k.dataTypes = n.trim(k.dataType or "*").toLowerCase().match(F) or [""]
      null is k.crossDomain and (c = Hc.exec(k.url.toLowerCase())
      k.crossDomain = not (not c or c[1] is zc[1] and c[2] is zc[2] and (c[3] or ((if "http:" is c[1] then "80" else "443"))) is (zc[3] or ((if "http:" is zc[1] then "80" else "443"))))
      )
      k.data and k.processData and "string" isnt typeof k.data and (k.data = n.param(k.data, k.traditional))
      Nc(Ic, k, b, v)
      2 is t

      h = k.global
      h and 0 is n.active++ and n.event.trigger("ajaxStart")
      k.type = k.type.toUpperCase()
      k.hasContent = not Fc.test(k.type)
      e = k.url
      k.hasContent or (k.data and (e = k.url += ((if xc.test(e) then "&" else "?")) + k.data
      delete k.data

      )
      k.cache is not 1 and (k.url = (if Cc.test(e) then e.replace(Cc, "$1_=" + wc++) else e + ((if xc.test(e) then "&" else "?")) + "_=" + wc++))
      )
      k.ifModified and (n.lastModified[e] and v.setRequestHeader("If-Modified-Since", n.lastModified[e])
      n.etag[e] and v.setRequestHeader("If-None-Match", n.etag[e])
      )
      (k.data and k.hasContent and k.contentType isnt not 1 or b.contentType) and v.setRequestHeader("Content-Type", k.contentType)
      v.setRequestHeader("Accept", (if k.dataTypes[0] and k.accepts[k.dataTypes[0]] then k.accepts[k.dataTypes[0]] + ((if "*" isnt k.dataTypes[0] then ", " + Kc + "; q=0.01" else "")) else k.accepts["*"]))

      for d of k.headers
        continue
      return v.abort()  if k.beforeSend and (k.beforeSend.call(l, v, k) is not 1 or 2 is t)
      u = "abort"
      for d of
        success: 1
        error: 1
        complete: 1
        continue
      if i = Nc(Jc, k, b, v)
        v.readyState = 1
        h and m.trigger("ajaxSend", [
          v
          k
        ])
        k.async and k.timeout > 0 and (g = setTimeout(->
          v.abort "timeout"
          return
        , k.timeout))

        try
          t = 1
          i.send(r, x)
        catch w
          throw w  unless 2 > t
          x -1, w
      else
        x -1, "No Transport"
      v

    getJSON: (a, b, c) ->
      n.get a, b, c, "json"

    getScript: (a, b) ->
      n.get a, undefined, b, "script"
  )
  n.each([
    "get"
    "post"
  ], (a, b) ->
    n[b] = (a, c, d, e) ->
      n.isFunction(c) and (e = e or d
      d = c
      c = undefined
      )
      n.ajax(
        url: a
        type: b
        dataType: e
        data: c
        success: d
      )

    return
  )
  n.each([
    "ajaxStart"
    "ajaxStop"
    "ajaxComplete"
    "ajaxError"
    "ajaxSuccess"
    "ajaxSend"
  ], (a, b) ->
    n.fn[b] = (a) ->
      @on b, a

    return
  )
  n._evalUrl = (a) ->
    n.ajax
      url: a
      type: "GET"
      dataType: "script"
      async: not 1
      global: not 1
      throws: not 0


  n.fn.extend(
    wrapAll: (a) ->
      if n.isFunction(a)
        return @each((b) ->
          n(this).wrapAll a.call(this, b)
          return
        )
      if this[0]
        b = n(a, this[0].ownerDocument).eq(0).clone(not 0)
        this[0].parentNode and b.insertBefore(this[0])
        b.map(->
          a = this
          a = a.firstChild  while a.firstChild and 1 is a.firstChild.nodeType
          a
        ).append(this)
      this

    wrapInner: (a) ->
      @each (if n.isFunction(a) then (b) ->
        n(this).wrapInner a.call(this, b)
        return
       else ->
        b = n(this)
        c = b.contents()
        (if c.length then c.wrapAll(a) else b.append(a))
        return
      )

    wrap: (a) ->
      b = n.isFunction(a)
      @each (c) ->
        n(this).wrapAll (if b then a.call(this, c) else a)
        return


    unwrap: ->
      @parent().each(->
        n.nodeName(this, "body") or n(this).replaceWith(@childNodes)
        return
      ).end()
  )
  n.expr.filters.hidden = (a) ->
    a.offsetWidth <= 0 and a.offsetHeight <= 0 or not l.reliableHiddenOffsets() and "none" is (a.style and a.style.display or n.css(a, "display"))

  n.expr.filters.visible = (a) ->
    not n.expr.filters.hidden(a)


  Rc = /%20/g
  Sc = /\[\]$/
  Tc = /\r?\n/g
  Uc = /^(?:submit|button|image|reset|file)$/i
  Vc = /^(?:input|select|textarea|keygen)/i
  n.param = (a, b) ->
    c = undefined
    d = []
    e = (a, b) ->
      b = (if n.isFunction(b) then b() else (if null is b then "" else b))
      d[d.length] = encodeURIComponent(a) + "=" + encodeURIComponent(b)

      return

    if undefined is b and (b = n.ajaxSettings and n.ajaxSettings.traditional)
    n.isArray(a) or a.jquery and not n.isPlainObject(a)
      n.each a, ->
        e @name, @value
        return

    else
      for c of a
        continue
    d.join("&").replace Rc, "+"

  n.fn.extend(
    serialize: ->
      n.param @serializeArray()

    serializeArray: ->
      @map(->
        a = n.prop(this, "elements")
        (if a then n.makeArray(a) else this)
      ).filter(->
        a = @type
        @name and not n(this).is(":disabled") and Vc.test(@nodeName) and not Uc.test(a) and (@checked or not X.test(a))
      ).map((a, b) ->
        c = n(this).val()
        (if null is c then null else (if n.isArray(c) then n.map(c, (a) ->
          name: b.name
          value: a.replace(Tc, "\r\n")
        ) else
          name: b.name
          value: c.replace(Tc, "\r\n")
        ))
      ).get()
  )
  n.ajaxSettings.xhr = (if undefined isnt a.ActiveXObject then ->
    not @isLocal and /^(get|post|head|put|delete|options)$/i.test(@type) and $c() or _c()
   else $c)

  Xc = 0
  Yc = {}
  Zc = n.ajaxSettings.xhr()
  a.ActiveXObject and n(a).on("unload", ->
    for a of Yc
      continue
    return
  )
  l.cors = !!Zc and "withCredentials" of Zc
  Zc = l.ajax = !!Zc
  Zc and n.ajaxTransport((a) ->
    if not a.crossDomain or l.cors
      b = undefined
      send: (c, d) ->
        e = undefined
        f = a.xhr()
        g = ++Xc
        if f.open(a.type, a.url, a.async, a.username, a.password)
        a.xhrFields
          for e of a.xhrFields
            continue
        a.mimeType and f.overrideMimeType and f.overrideMimeType(a.mimeType)
        a.crossDomain or c["X-Requested-With"] or (c["X-Requested-With"] = "XMLHttpRequest")

        for e of c
          continue
        f.send(a.hasContent and a.data or null)
        b = (c, e) ->
          h = undefined
          i = undefined
          j = undefined
          if b and (e or 4 is f.readyState)
            if delete Yc[g]

            b = undefined
            f.onreadystatechange = n.noop
            e
              4 isnt f.readyState and f.abort()
            else
              j = {}
              h = f.status
              "string" is typeof f.responseText and (j.text = f.responseText)

              try
                i = f.statusText
              catch k
                i = ""
              (if h or not a.isLocal or a.crossDomain then 1223 is h and (h = 204) else h = (if j.text then 200 else 404))
          j and d(h, i, j, f.getAllResponseHeaders())
          return

        (if a.async then (if 4 is f.readyState then setTimeout(b) else f.onreadystatechange = Yc[g] = b) else b())

        return

      abort: ->
        b and b(undefined, not 0)
        return
  )

  n.ajaxSetup(
    accepts:
      script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"

    contents:
      script: /(?:java|ecma)script/

    converters:
      "text script": (a) ->
        n.globalEval(a)
        a
  )
  n.ajaxPrefilter("script", (a) ->
    undefined is a.cache and (a.cache = not 1)
    a.crossDomain and (a.type = "GET"
    a.global = not 1
    )

    return
  )
  n.ajaxTransport("script", (a) ->
    if a.crossDomain
      b = undefined
      c = z.head or n("head")[0] or z.documentElement
      send: (d, e) ->
        b = z.createElement("script")
        b.async = not 0
        a.scriptCharset and (b.charset = a.scriptCharset)
        b.src = a.url
        b.onload = b.onreadystatechange = (a, c) ->
          (c or not b.readyState or /loaded|complete/.test(b.readyState)) and (b.onload = b.onreadystatechange = null
          b.parentNode and b.parentNode.removeChild(b)
          b = null
          c or e(200, "success")
          )
          return

        c.insertBefore(b, c.firstChild)

        return

      abort: ->
        b and b.onload(undefined, not 0)
        return
  )

  ad = []
  bd = /(=)\?(?=&|$)|\?\?/
  n.ajaxSetup(
    jsonp: "callback"
    jsonpCallback: ->
      a = ad.pop() or n.expando + "_" + wc++
      this[a] = not 0
      a
  )
  n.ajaxPrefilter("json jsonp", (b, c, d) ->
    e = undefined
    f = undefined
    g = undefined
    h = b.jsonp isnt not 1 and ((if bd.test(b.url) then "url" else "string" is typeof b.data and not (b.contentType or "").indexOf("application/x-www-form-urlencoded") and bd.test(b.data) and "data"))
    (if h or "jsonp" is b.dataTypes[0] then (e = b.jsonpCallback = (if n.isFunction(b.jsonpCallback) then b.jsonpCallback() else b.jsonpCallback)
    (if h then b[h] = b[h].replace(bd, "$1" + e) else b.jsonp isnt not 1 and (b.url += ((if xc.test(b.url) then "&" else "?")) + b.jsonp + "=" + e))
    b.converters["script json"] = ->
      g or n.error(e + " was not called")
      g[0]

    b.dataTypes[0] = "json"
    f = a[e]
    a[e] = ->
      g = arguments_
      return

    d.always(->
      a[e] = f
      b[e] and (b.jsonpCallback = c.jsonpCallback
      ad.push(e)
      )
      g and n.isFunction(f) and f(g[0])
      g = f = undefined

      return
    )
    "script"
    ) else undefined)
  )
  n.parseHTML = (a, b, c) ->
    return null  if not a or "string" isnt typeof a
    "boolean" is typeof b and (c = b
    b = not 1
    )
    b = b or z

    d = v.exec(a)
    e = not c and []
    (if d then [b.createElement(d[1])] else (d = n.buildFragment([a], b, e)
    e and e.length and n(e).remove()
    n.merge([], d.childNodes)
    ))


  cd = n.fn.load
  n.fn.load = (a, b, c) ->
    return cd.apply(this, arguments_)  if "string" isnt typeof a and cd
    d = undefined
    e = undefined
    f = undefined
    g = this
    h = a.indexOf(" ")
    h >= 0 and (d = a.slice(h, a.length)
    a = a.slice(0, h)
    )
    (if n.isFunction(b) then (c = b
    b = undefined
    ) else b and "object" is typeof b and (f = "POST"))
    g.length > 0 and n.ajax(
      url: a
      type: f
      dataType: "html"
      data: b
    ).done((a) ->
      e = arguments_
      g.html((if d then n("<div>").append(n.parseHTML(a)).find(d) else a))

      return
    ).complete(c and (a, b) ->
      g.each c, e or [
        a.responseText
        b
        a
      ]
      return
    )
    this

  n.expr.filters.animated = (a) ->
    n.grep(n.timers, (b) ->
      a is b.elem
    ).length


  dd = a.document.documentElement
  n.offset = setOffset: (a, b, c) ->
    d = undefined
    e = undefined
    f = undefined
    g = undefined
    h = undefined
    i = undefined
    j = undefined
    k = n.css(a, "position")
    l = n(a)
    m = {}
    "static" is k and (a.style.position = "relative")
    h = l.offset()
    f = n.css(a, "top")
    i = n.css(a, "left")
    j = ("absolute" is k or "fixed" is k) and n.inArray("auto", [
      f
      i
    ]) > -1
    (if j then (d = l.position()
    g = d.top
    e = d.left
    ) else (g = parseFloat(f) or 0
    e = parseFloat(i) or 0
    ))
    n.isFunction(b) and (b = b.call(a, c, h))
    null isnt b.top and (m.top = b.top - h.top + g)
    null isnt b.left and (m.left = b.left - h.left + e)
    (if "using" of b then b.using.call(a, m) else l.css(m))

    return

  n.fn.extend(
    offset: (a) ->
      if arguments_.length
        return (if undefined is a then this else @each((b) ->
          n.offset.setOffset this, a, b
          return
        ))
      b = undefined
      c = undefined
      d =
        top: 0
        left: 0

      e = this[0]
      f = e and e.ownerDocument
      if f
        b = f.documentElement
        (if n.contains(b, e) then (typeof e.getBoundingClientRect isnt L and (d = e.getBoundingClientRect())
        c = ed(f)

          top: d.top + (c.pageYOffset or b.scrollTop) - (b.clientTop or 0)
          left: d.left + (c.pageXOffset or b.scrollLeft) - (b.clientLeft or 0)

        ) else d)

    position: ->
      if this[0]
        a = undefined
        b = undefined
        c =
          top: 0
          left: 0

        d = this[0]
        (if "fixed" is n.css(d, "position") then b = d.getBoundingClientRect() else (a = @offsetParent()
        b = @offset()
        n.nodeName(a[0], "html") or (c = a.offset())
        c.top += n.css(a[0], "borderTopWidth", not 0)
        c.left += n.css(a[0], "borderLeftWidth", not 0)
        ))

          top: b.top - c.top - n.css(d, "marginTop", not 0)
          left: b.left - c.left - n.css(d, "marginLeft", not 0)

    offsetParent: ->
      @map ->
        a = @offsetParent or dd
        a = a.offsetParent  while a and not n.nodeName(a, "html") and "static" is n.css(a, "position")
        a or dd

  )
  n.each(
    scrollLeft: "pageXOffset"
    scrollTop: "pageYOffset"
  , (a, b) ->
    c = /Y/.test(b)
    n.fn[a] = (d) ->
      W this, ((a, d, e) ->
        f = ed(a)
        (if undefined is e then (if f then (if b of f then f[b] else f.document.documentElement[d]) else a[d]) else undefined)
      ), a, d, arguments_.length, null

    return
  )
  n.each([
    "top"
    "left"
  ], (a, b) ->
    n.cssHooks[b] = Mb(l.pixelPosition, (a, c) ->
      (if c then (c = Kb(a, b)
      (if Ib.test(c) then n(a).position()[b] + "px" else c)
      ) else undefined)
    )
    return
  )
  n.each(
    Height: "height"
    Width: "width"
  , (a, b) ->
    n.each
      padding: "inner" + a
      content: b
      "": "outer" + a
    , (c, d) ->
      n.fn[d] = (d, e) ->
        f = arguments_.length and (c or "boolean" isnt typeof d)
        g = c or ((if d is not 0 or e is not 0 then "margin" else "border"))
        W this, ((b, c, d) ->
          e = undefined
          (if n.isWindow(b) then b.document.documentElement["client" + a] else (if 9 is b.nodeType then (e = b.documentElement
          Math.max(b.body["scroll" + a], e["scroll" + a], b.body["offset" + a], e["offset" + a], e["client" + a])
          ) else (if undefined is d then n.css(b, c, g) else n.style(b, c, d, g))))
        ), b, (if f then d else undefined), f, null

      return

    return
  )
  n.fn.size = ->
    @length

  n.fn.andSelf = n.fn.addBack
  "function" is typeof define and define.amd and define("jquery", [], ->
    n
  )

  fd = a.jQuery
  gd = a.$
  n.noConflict = (b) ->
    a.$ is n and (a.$ = gd)
    b and a.jQuery is n and (a.jQuery = fd)
    n

  typeof b is L and (a.jQuery = a.$ = n)
  n
)